Update app.py

app.py

@@ -8,22 +8,13 @@ from scipy.optimize import minimize
 import plotly.express as px
 from scipy.stats import t, f
 import gradio as gr
+import io
+import os
+from zipfile import ZipFile
 
 class RSM_BoxBehnken:
     def __init__(self, data, x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels):
-        """
-        Inicializa la clase con los datos del diseño Box-Behnken.
-
-        Args:
-            data (pd.DataFrame): DataFrame con los datos del experimento.
-            x1_name (str): Nombre de la primera variable independiente.
-            x2_name (str): Nombre de la segunda variable independiente.
-            x3_name (str): Nombre de la tercera variable independiente.
-            y_name (str): Nombre de la variable dependiente.
-            x1_levels (list): Niveles de la primera variable independiente.
-            x2_levels (list): Niveles de la segunda variable independiente.
-            x3_levels (list): Niveles de la tercera variable independiente.
-        """
+        # ... (El código de la clase RSM_BoxBehnken se mantiene igual, solo se modifican las funciones que generan dataframes o strings)
         self.data = data.copy()
         self.model = None
         self.model_simplified = None
@@ -41,15 +32,6 @@ class RSM_BoxBehnken:
         self.x3_levels = x3_levels
 
     def get_levels(self, variable_name):
-        """
-        Obtiene los niveles para una variable específica.
-        
-        Args:
-            variable_name (str): Nombre de la variable.
-        
-        Returns:
-            list: Niveles de la variable.
-        """
         if variable_name == self.x1_name:
             return self.x1_levels
         elif variable_name == self.x2_name:
@@ -60,9 +42,6 @@ class RSM_BoxBehnken:
             raise ValueError(f"Variable desconocida: {variable_name}")
 
     def fit_model(self):
-        """
-        Ajusta el modelo de segundo orden completo a los datos.
-        """
         formula = f'{self.y_name} ~ {self.x1_name} + {self.x2_name} + {self.x3_name} + ' \
                   f'I({self.x1_name}**2) + I({self.x2_name}**2) + I({self.x3_name}**2) + ' \
                   f'{self.x1_name}:{self.x2_name} + {self.x1_name}:{self.x3_name} + {self.x2_name}:{self.x3_name}'
@@ -72,9 +51,6 @@ class RSM_BoxBehnken:
         return self.model, self.pareto_chart(self.model, "Pareto - Modelo Completo")
 
     def fit_simplified_model(self):
-        """
-        Ajusta el modelo de segundo orden a los datos, eliminando términos no significativos.
-        """
         formula = f'{self.y_name} ~ {self.x1_name} + {self.x2_name} + ' \
                   f'I({self.x1_name}**2) + I({self.x2_name}**2) + I({self.x3_name}**2)'
         self.model_simplified = smf.ols(formula, data=self.data).fit()
@@ -83,12 +59,6 @@ class RSM_BoxBehnken:
         return self.model_simplified, self.pareto_chart(self.model_simplified, "Pareto - Modelo Simplificado")
 
     def optimize(self, method='Nelder-Mead'):
-        """
-        Encuentra los niveles óptimos de los factores para maximizar la respuesta usando el modelo simplificado.
-
-        Args:
-            method (str): Método de optimización a utilizar (por defecto, 'Nelder-Mead').
-        """
         if self.model_simplified is None:
             print("Error: Ajusta el modelo simplificado primero.")
             return
@@ -102,85 +72,60 @@ class RSM_BoxBehnken:
         self.optimized_results = minimize(objective_function, x0, method=method, bounds=bounds)
         self.optimal_levels = self.optimized_results.x
         
-        # Convertir niveles óptimos de codificados a naturales
         optimal_levels_natural = [
-            self.coded_to_natural(self.optimal_levels[0], self.x1_name),
-            self.coded_to_natural(self.optimal_levels[1], self.x2_name),
-            self.coded_to_natural(self.optimal_levels[2], self.x3_name)
+            round(self.coded_to_natural(self.optimal_levels[0], self.x1_name), 3),
+            round(self.coded_to_natural(self.optimal_levels[1], self.x2_name), 3),
+            round(self.coded_to_natural(self.optimal_levels[2], self.x3_name), 3)
         ]
-        # Crear la tabla de optimización
         optimization_table = pd.DataFrame({
             'Variable': [self.x1_name, self.x2_name, self.x3_name],
             'Nivel Óptimo (Natural)': optimal_levels_natural,
-            'Nivel Óptimo (Codificado)': self.optimal_levels
+            'Nivel Óptimo (Codificado)': [round(x, 3) for x in self.optimal_levels]
         })
 
         return optimization_table
 
     def plot_rsm_individual(self, fixed_variable, fixed_level):
-        """
-        Genera un gráfico de superficie de respuesta (RSM) individual para una configuración específica.
-
-        Args:
-            fixed_variable (str): Nombre de la variable a mantener fija.
-            fixed_level (float): Nivel al que se fija la variable (en unidades naturales).
-
-        Returns:
-            go.Figure: Objeto de figura de Plotly.
-        """
         if self.model_simplified is None:
             print("Error: Ajusta el modelo simplificado primero.")
             return None
 
-        # Determinar las variables que varían y sus niveles naturales
         varying_variables = [var for var in [self.x1_name, self.x2_name, self.x3_name] if var != fixed_variable]
         
-        # Establecer los niveles naturales para las variables que varían
         x_natural_levels = self.get_levels(varying_variables[0])
         y_natural_levels = self.get_levels(varying_variables[1])
 
-        # Crear una malla de puntos para las variables que varían (en unidades naturales)
         x_range_natural = np.linspace(x_natural_levels[0], x_natural_levels[-1], 100)
         y_range_natural = np.linspace(y_natural_levels[0], y_natural_levels[-1], 100)
         x_grid_natural, y_grid_natural = np.meshgrid(x_range_natural, y_range_natural)
 
-        # Convertir la malla de variables naturales a codificadas
         x_grid_coded = self.natural_to_coded(x_grid_natural, varying_variables[0])
         y_grid_coded = self.natural_to_coded(y_grid_natural, varying_variables[1])
 
-        # Crear un DataFrame para la predicción con variables codificadas
         prediction_data = pd.DataFrame({
             varying_variables[0]: x_grid_coded.flatten(),
             varying_variables[1]: y_grid_coded.flatten(),
         })
         prediction_data[fixed_variable] = self.natural_to_coded(fixed_level, fixed_variable)
 
-        # Calcular los valores predichos
         z_pred = self.model_simplified.predict(prediction_data).values.reshape(x_grid_coded.shape)
 
-        # 1. Identificar los dos factores que varían
         varying_variables = [var for var in [self.x1_name, self.x2_name, self.x3_name] if var != fixed_variable]
 
-        # 2. Filtrar por el nivel de la variable fija (en codificado)
         fixed_level_coded = self.natural_to_coded(fixed_level, fixed_variable)
         subset_data = self.data[np.isclose(self.data[fixed_variable], fixed_level_coded)]
 
-        # 3. Filtrar por niveles válidos en las variables que varían
         valid_levels = [-1, 0, 1]
         experiments_data = subset_data[
             subset_data[varying_variables[0]].isin(valid_levels) &
             subset_data[varying_variables[1]].isin(valid_levels)
         ]
 
-        # Convertir coordenadas de experimentos a naturales
         experiments_x_natural = experiments_data[varying_variables[0]].apply(lambda x: self.coded_to_natural(x, varying_variables[0]))
         experiments_y_natural = experiments_data[varying_variables[1]].apply(lambda x: self.coded_to_natural(x, varying_variables[1]))
 
-        # Crear el gráfico de superficie con variables naturales en los ejes y transparencia
         fig = go.Figure(data=[go.Surface(z=z_pred, x=x_grid_natural, y=y_grid_natural, colorscale='Viridis', opacity=0.7, showscale=True)])
 
-        # --- Añadir cuadrícula a la superficie ---
-        # Líneas en la dirección x
         for i in range(x_grid_natural.shape[0]):
             fig.add_trace(go.Scatter3d(
                 x=x_grid_natural[i, :],
@@ -191,7 +136,6 @@ class RSM_BoxBehnken:
                 showlegend=False,
                 hoverinfo='skip'
             ))
-        # Líneas en la dirección y
         for j in range(x_grid_natural.shape[1]):
             fig.add_trace(go.Scatter3d(
                 x=x_grid_natural[:, j],
@@ -203,10 +147,6 @@ class RSM_BoxBehnken:
                 hoverinfo='skip'
             ))
 
-        # --- Fin de la adición de la cuadrícula ---
-
-        # Añadir los puntos de los experimentos en la superficie de respuesta con diferentes colores y etiquetas
-        # Crear una lista de colores y etiquetas para los puntos
         colors = ['red', 'blue', 'green', 'purple', 'orange', 'yellow', 'cyan', 'magenta']
         point_labels = []
         for i, row in experiments_data.iterrows():
@@ -217,22 +157,17 @@ class RSM_BoxBehnken:
             y=experiments_y_natural,
             z=experiments_data[self.y_name],
             mode='markers+text',
-            marker=dict(size=4, color=colors[:len(experiments_x_natural)]),  # Usar colores de la lista
-            text=point_labels,  # Usar las etiquetas creadas
+            marker=dict(size=4, color=colors[:len(experiments_x_natural)]),
+            text=point_labels,
             textposition='top center',
             name='Experimentos'
         ))
 
-        # Añadir etiquetas y título con variables naturales
         fig.update_layout(
             scene=dict(
                 xaxis_title=varying_variables[0] + " (g/L)",
                 yaxis_title=varying_variables[1] + " (g/L)",
                 zaxis_title=self.y_name,
-                # Puedes mantener la configuración de grid en los planos si lo deseas
-                # xaxis=dict(showgrid=True, gridwidth=1, gridcolor='lightgray'),
-                # yaxis=dict(showgrid=True, gridwidth=1, gridcolor='lightgray'),
-                # zaxis=dict(showgrid=True, gridwidth=1, gridcolor='lightgray')
             ),
             title=f"{self.y_name} vs {varying_variables[0]} y {varying_variables[1]}<br><sup>{fixed_variable} fijo en {fixed_level:.2f} (g/L) (Modelo Simplificado)</sup>",
             height=800,
@@ -255,46 +190,36 @@ class RSM_BoxBehnken:
             self.x2_name: self.x2_levels,
             self.x3_name: self.x3_levels
         }
+        
+        figs = []
 
         # Generar y mostrar gráficos individuales
         for fixed_variable in [self.x1_name, self.x2_name, self.x3_name]:
             for level in levels_to_plot_natural[fixed_variable]:
                 fig = self.plot_rsm_individual(fixed_variable, level)
                 if fig is not None:
-                    fig.show()
+                    figs.append(fig)
+        return figs
 
     def coded_to_natural(self, coded_value, variable_name):
-        """Convierte un valor codificado a su valor natural."""
         levels = self.get_levels(variable_name)
         return levels[0] + (coded_value + 1) * (levels[-1] - levels[0]) / 2
 
     def natural_to_coded(self, natural_value, variable_name):
-        """Convierte un valor natural a su valor codificado."""
         levels = self.get_levels(variable_name)
         return -1 + 2 * (natural_value - levels[0]) / (levels[-1] - levels[0])
 
     def pareto_chart(self, model, title):
-        """
-        Genera un diagrama de Pareto para los efectos estandarizados de un modelo,
-        incluyendo la línea de significancia.
-
-        Args:
-            model: Modelo ajustado de statsmodels.
-            title (str): Título del gráfico.
-        """
-        # Calcular los efectos estandarizados
-        tvalues = model.tvalues[1:]  # Excluir la Intercept
+        tvalues = model.tvalues[1:]
         abs_tvalues = np.abs(tvalues)
         sorted_idx = np.argsort(abs_tvalues)[::-1]
         sorted_tvalues = abs_tvalues[sorted_idx]
         sorted_names = tvalues.index[sorted_idx]
 
-        # Calcular el valor crítico de t para la línea de significancia
-        alpha = 0.05  # Nivel de significancia
-        dof = model.df_resid  # Grados de libertad residuales
+        alpha = 0.05
+        dof = model.df_resid
         t_critical = t.ppf(1 - alpha / 2, dof)
 
-        # Crear el diagrama de Pareto
         fig = px.bar(
             x=sorted_tvalues,
             y=sorted_names,
@@ -304,7 +229,6 @@ class RSM_BoxBehnken:
         )
         fig.update_yaxes(autorange="reversed")
 
-        # Agregar la línea de significancia
         fig.add_vline(x=t_critical, line_dash="dot",
                       annotation_text=f"t crítico = {t_critical:.2f}",
                       annotation_position="bottom right")
@@ -312,37 +236,31 @@ class RSM_BoxBehnken:
         return fig
 
     def get_simplified_equation(self):
-        """
-        Imprime la ecuación del modelo simplificado.
-        """
         if self.model_simplified is None:
             print("Error: Ajusta el modelo simplificado primero.")
             return None
 
         coefficients = self.model_simplified.params
-        equation = f"{self.y_name} = {coefficients['Intercept']:.4f}"
+        equation = f"{self.y_name} = {coefficients['Intercept']:.3f}"
 
         for term, coef in coefficients.items():
             if term != 'Intercept':
               if term == f'{self.x1_name}':
-                equation += f" + {coef:.4f}*{self.x1_name}"
+                equation += f" + {coef:.3f}*{self.x1_name}"
               elif term == f'{self.x2_name}':
-                equation += f" + {coef:.4f}*{self.x2_name}"
+                equation += f" + {coef:.3f}*{self.x2_name}"
               elif term == f'{self.x3_name}':
-                equation += f" + {coef:.4f}*{self.x3_name}"
+                equation += f" + {coef:.3f}*{self.x3_name}"
               elif term == f'I({self.x1_name} ** 2)':
-                equation += f" + {coef:.4f}*{self.x1_name}^2"
+                equation += f" + {coef:.3f}*{self.x1_name}^2"
               elif term == f'I({self.x2_name} ** 2)':
-                equation += f" + {coef:.4f}*{self.x2_name}^2"
+                equation += f" + {coef:.3f}*{self.x2_name}^2"
               elif term == f'I({self.x3_name} ** 2)':
-                equation += f" + {coef:.4f}*{self.x3_name}^2"
+                equation += f" + {coef:.3f}*{self.x3_name}^2"
 
         return equation
 
     def generate_prediction_table(self):
-      """
-      Genera una tabla con los valores actuales, predichos y residuales.
-      """
       if self.model_simplified is None:
           print("Error: Ajusta el modelo simplificado primero.")
           return None
@@ -350,30 +268,28 @@ class RSM_BoxBehnken:
       self.data['Predicho'] = self.model_simplified.predict(self.data)
       self.data['Residual'] = self.data[self.y_name] - self.data['Predicho']
 
-      return self.data[[self.y_name, 'Predicho', 'Residual']]
+      # Redondear a 3 decimales en la tabla de predicciones
+      prediction_table = self.data[[self.y_name, 'Predicho', 'Residual']].copy()
+      prediction_table[self.y_name] = prediction_table[self.y_name].round(3)
+      prediction_table['Predicho'] = prediction_table['Predicho'].round(3)
+      prediction_table['Residual'] = prediction_table['Residual'].round(3)
+
+      return prediction_table
 
     def calculate_contribution_percentage(self):
-      """
-      Calcula el porcentaje de contribución de cada factor a la variabilidad de la respuesta (AIA).
-      """
       if self.model_simplified is None:
           print("Error: Ajusta el modelo simplificado primero.")
           return None
 
-      # ANOVA del modelo simplificado
       anova_table = sm.stats.anova_lm(self.model_simplified, typ=2)
-
-      # Suma de cuadrados total
       ss_total = anova_table['sum_sq'].sum()
 
-      # Crear tabla de contribución
       contribution_table = pd.DataFrame({
           'Factor': [],
           'Suma de Cuadrados': [],
           '% Contribución': []
       })
       
-      # Calcular porcentaje de contribución para cada factor
       for index, row in anova_table.iterrows():
           if index != 'Residual':
             factor_name = index
@@ -389,85 +305,65 @@ class RSM_BoxBehnken:
 
             contribution_table = pd.concat([contribution_table, pd.DataFrame({
                 'Factor': [factor_name],
-                'Suma de Cuadrados': [ss_factor],
-                '% Contribución': [contribution_percentage]
+                'Suma de Cuadrados': [round(ss_factor, 3)],
+                '% Contribución': [round(contribution_percentage, 3)]
             })], ignore_index=True)
 
       return contribution_table
 
     def calculate_detailed_anova(self):
-        """
-        Calcula la tabla ANOVA detallada con la descomposición del error residual.
-        """
         if self.model_simplified is None:
             print("Error: Ajusta el modelo simplificado primero.")
             return None
 
-        # --- ANOVA detallada ---
-        # 1. Ajustar un modelo solo con los términos de primer orden y cuadráticos
         formula_reduced = f'{self.y_name} ~ {self.x1_name} + {self.x2_name} + {self.x3_name} + ' \
                           f'I({self.x1_name}**2) + I({self.x2_name}**2) + I({self.x3_name}**2)'
         model_reduced = smf.ols(formula_reduced, data=self.data).fit()
 
-        # 2. ANOVA del modelo reducido (para obtener la suma de cuadrados de la regresión)
         anova_reduced = sm.stats.anova_lm(model_reduced, typ=2)
 
-        # 3. Suma de cuadrados total
         ss_total = np.sum((self.data[self.y_name] - self.data[self.y_name].mean())**2)
 
-        # 4. Grados de libertad totales
         df_total = len(self.data) - 1
 
-        # 5. Suma de cuadrados de la regresión
-        ss_regression = anova_reduced['sum_sq'][:-1].sum() # Sumar todo excepto 'Residual'
+        ss_regression = anova_reduced['sum_sq'][:-1].sum()
 
-        # 6. Grados de libertad de la regresión
         df_regression = len(anova_reduced) - 1
 
-        # 7. Suma de cuadrados del error residual
         ss_residual = self.model_simplified.ssr
         df_residual = self.model_simplified.df_resid
 
-        # 8. Suma de cuadrados del error puro (se calcula a partir de las réplicas)
         replicas = self.data[self.data.duplicated(subset=[self.x1_name, self.x2_name, self.x3_name], keep=False)]
         ss_pure_error = replicas.groupby([self.x1_name, self.x2_name, self.x3_name])[self.y_name].var().sum()
         df_pure_error = len(replicas) - len(replicas.groupby([self.x1_name, self.x2_name, self.x3_name]))
 
-        # 9. Suma de cuadrados de la falta de ajuste
         ss_lack_of_fit = ss_residual - ss_pure_error
         df_lack_of_fit = df_residual - df_pure_error
 
-        # 10. Cuadrados medios
         ms_regression = ss_regression / df_regression
         ms_residual = ss_residual / df_residual
         ms_lack_of_fit = ss_lack_of_fit / df_lack_of_fit
         ms_pure_error = ss_pure_error / df_pure_error
 
-        # 11. Estadístico F y valor p para la falta de ajuste
         f_lack_of_fit = ms_lack_of_fit / ms_pure_error
-        p_lack_of_fit = 1 - f.cdf(f_lack_of_fit, df_lack_of_fit, df_pure_error) # Usar f.cdf de scipy.stats
+        p_lack_of_fit = 1 - f.cdf(f_lack_of_fit, df_lack_of_fit, df_pure_error)
 
-        # 12. Crear la tabla ANOVA detallada
         detailed_anova_table = pd.DataFrame({
             'Fuente de Variación': ['Regresión', 'Residual', 'Falta de Ajuste', 'Error Puro', 'Total'],
-            'Suma de Cuadrados': [ss_regression, ss_residual, ss_lack_of_fit, ss_pure_error, ss_total],
+            'Suma de Cuadrados': [round(ss_regression, 3), round(ss_residual, 3), round(ss_lack_of_fit, 3), round(ss_pure_error, 3), round(ss_total, 3)],
             'Grados de Libertad': [df_regression, df_residual, df_lack_of_fit, df_pure_error, df_total],
-            'Cuadrado Medio': [ms_regression, ms_residual, ms_lack_of_fit, ms_pure_error, np.nan],
-            'F': [np.nan, np.nan, f_lack_of_fit, np.nan, np.nan],
-            'Valor p': [np.nan, np.nan, p_lack_of_fit, np.nan, np.nan]
+            'Cuadrado Medio': [round(ms_regression, 3), round(ms_residual, 3), round(ms_lack_of_fit, 3), round(ms_pure_error, 3), np.nan],
+            'F': [np.nan, np.nan, round(f_lack_of_fit, 3), np.nan, np.nan],
+            'Valor p': [np.nan, np.nan, round(p_lack_of_fit, 3), np.nan, np.nan]
         })
         
-        # Calcular la suma de cuadrados y grados de libertad para la curvatura
         ss_curvature = anova_reduced['sum_sq'][f'I({self.x1_name} ** 2)'] + anova_reduced['sum_sq'][f'I({self.x2_name} ** 2)'] + anova_reduced['sum_sq'][f'I({self.x3_name} ** 2)']
         df_curvature = 3
 
-        # Añadir la fila de curvatura a la tabla ANOVA
-        detailed_anova_table.loc[len(detailed_anova_table)] = ['Curvatura', ss_curvature, df_curvature, ss_curvature / df_curvature, np.nan, np.nan]
+        detailed_anova_table.loc[len(detailed_anova_table)] = ['Curvatura', round(ss_curvature, 3), df_curvature, round(ss_curvature / df_curvature, 3), np.nan, np.nan]
 
-        # Reorganizar las filas para que la curvatura aparezca después de la regresión
         detailed_anova_table = detailed_anova_table.reindex([0, 5, 1, 2, 3, 4])
         
-        # Resetear el índice para que sea consecutivo
         detailed_anova_table = detailed_anova_table.reset_index(drop=True)
 
         return detailed_anova_table
@@ -475,39 +371,19 @@ class RSM_BoxBehnken:
 # --- Funciones para la interfaz de Gradio ---
 
 def load_data(x1_name, x2_name, x3_name, y_name, x1_levels_str, x2_levels_str, x3_levels_str, data_str):
-    """
-    Carga los datos del diseño Box-Behnken desde cajas de texto y crea la instancia de RSM_BoxBehnken.
-
-    Args:
-        x1_name (str): Nombre de la primera variable independiente.
-        x2_name (str): Nombre de la segunda variable independiente.
-        x3_name (str): Nombre de la tercera variable independiente.
-        y_name (str): Nombre de la variable dependiente.
-        x1_levels_str (str): Niveles de la primera variable, separados por comas.
-        x2_levels_str (str): Niveles de la segunda variable, separados por comas.
-        x3_levels_str (str): Niveles de la tercera variable, separados por comas.
-        data_str (str): Datos del experimento en formato CSV, separados por comas.
-
-    Returns:
-        tuple: (pd.DataFrame, str, str, str, str, list, list, list, gr.update)
-    """
     try:
-        # Convertir los niveles a listas de números
         x1_levels = [float(x.strip()) for x in x1_levels_str.split(',')]
         x2_levels = [float(x.strip()) for x in x2_levels_str.split(',')]
         x3_levels = [float(x.strip()) for x in x3_levels_str.split(',')]
 
-        # Crear DataFrame a partir de la cadena de datos
         data_list = [row.split(',') for row in data_str.strip().split('\n')]
         column_names = ['Exp.', x1_name, x2_name, x3_name, y_name]
         data = pd.DataFrame(data_list, columns=column_names)
-        data = data.apply(pd.to_numeric, errors='coerce')  # Convertir a numérico
+        data = data.apply(pd.to_numeric, errors='coerce')
 
-        # Validar que el DataFrame tenga las columnas correctas
         if not all(col in data.columns for col in column_names):
             raise ValueError("El formato de los datos no es correcto.")
 
-        # Crear la instancia de RSM_BoxBehnken
         global rsm
         rsm = RSM_BoxBehnken(data, x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels)
 
@@ -527,8 +403,7 @@ def fit_and_optimize_model():
     prediction_table = rsm.generate_prediction_table()
     contribution_table = rsm.calculate_contribution_percentage()
     anova_table = rsm.calculate_detailed_anova()
-    
-    # Formatear la ecuación para que se vea mejor en Markdown
+
     equation_formatted = equation.replace(" + ", "<br>+ ").replace(" ** ", "^").replace("*", " × ")
     equation_formatted = f"### Ecuación del Modelo Simplificado:<br>{equation_formatted}"
 
@@ -538,8 +413,64 @@ def fit_and_optimize_model():
 def generate_rsm_plot(fixed_variable, fixed_level):
     if 'rsm' not in globals():
         return None, "Error: Carga los datos primero."
-    fig = rsm.plot_rsm_individual(fixed_variable, fixed_level)
-    return fig
+    
+    # Generar todas las gráficas
+    all_figs = rsm.generate_all_plots()
+
+    # Crear una lista de figuras para la salida
+    plot_outputs = []
+    for fig in all_figs:
+        # Convertir la figura a una imagen en formato PNG
+        img_bytes = fig.to_image(format="png")
+        plot_outputs.append(img_bytes)
+
+    # Retornar la lista de imágenes
+    return plot_outputs
+
+def download_excel():
+    if 'rsm' not in globals():
+        return None, "Error: Carga los datos y ajusta el modelo primero."
+
+    output = io.BytesIO()
+    with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+        rsm.data.to_excel(writer, sheet_name='Datos', index=False)
+        rsm.generate_prediction_table().to_excel(writer, sheet_name='Predicciones', index=False)
+        rsm.optimize().to_excel(writer, sheet_name='Optimizacion', index=False)
+        rsm.calculate_contribution_percentage().to_excel(writer, sheet_name='Contribucion', index=False)
+        rsm.calculate_detailed_anova().to_excel(writer, sheet_name='ANOVA', index=False)
+
+    output.seek(0)
+    return gr.File.update(value=output, visible=True, filename="resultados_rsm.xlsx")
+
+def download_images():
+    if 'rsm' not in globals():
+        return None, "Error: Carga los datos y ajusta el modelo primero."
+
+    # Crear un directorio temporal para guardar las imágenes
+    temp_dir = "temp_images"
+    os.makedirs(temp_dir, exist_ok=True)
+
+    # Generar todas las gráficas y guardarlas como imágenes PNG
+    all_figs = rsm.generate_all_plots()
+    for i, fig in enumerate(all_figs):
+        img_path = os.path.join(temp_dir, f"plot_{i}.png")
+        fig.write_image(img_path)
+
+    # Comprimir las imágenes en un archivo ZIP
+    zip_buffer = io.BytesIO()
+    with ZipFile(zip_buffer, "w") as zip_file:
+        for filename in os.listdir(temp_dir):
+            file_path = os.path.join(temp_dir, filename)
+            zip_file.write(file_path, arcname=filename)
+
+    # Eliminar el directorio temporal
+    for filename in os.listdir(temp_dir):
+        file_path = os.path.join(temp_dir, filename)
+        os.remove(file_path)
+    os.rmdir(temp_dir)
+
+    zip_buffer.seek(0)
+    return gr.File.update(value=zip_buffer, visible=True, filename="graficos_rsm.zip")
 
 # --- Crear la interfaz de Gradio ---
 
@@ -582,6 +513,8 @@ with gr.Blocks() as demo:
     with gr.Row(visible=False) as analysis_row:
         with gr.Column():
             fit_button = gr.Button("Ajustar Modelo y Optimizar")
+            download_excel_button = gr.Button("Descargar Tablas en Excel")
+            download_images_button = gr.Button("Descargar Gráficos en ZIP")
             gr.Markdown("**Modelo Completo**")
             model_completo_output = gr.HTML()
             pareto_completo_output = gr.Plot()
@@ -598,7 +531,7 @@ with gr.Blocks() as demo:
             fixed_variable_input = gr.Dropdown(label="Variable Fija", choices=["Glucosa", "Extracto_de_Levadura", "Triptofano"], value="Glucosa")
             fixed_level_input = gr.Slider(label="Nivel de Variable Fija", minimum=0, maximum=1, step=0.01, value=0.5)
             plot_button = gr.Button("Generar Gráfico")
-            rsm_plot_output = gr.Plot()
+            rsm_plot_output = gr.Gallery(label="Gráficos RSM", columns=3, preview=True, height="auto")
 
     load_button.click(
         load_data,
@@ -607,8 +540,12 @@ with gr.Blocks() as demo:
     )
 
     fit_button.click(fit_and_optimize_model, outputs=[model_completo_output, pareto_completo_output, model_simplificado_output, pareto_simplificado_output, equation_output, optimization_table_output, prediction_table_output, contribution_table_output, anova_table_output])
+    
     plot_button.click(generate_rsm_plot, inputs=[fixed_variable_input, fixed_level_input], outputs=[rsm_plot_output])
 
+    download_excel_button.click(download_excel, outputs=[gr.File()])
+    download_images_button.click(download_images, outputs=[gr.File()])
+
     # Ejemplo de uso
     gr.Markdown("## Ejemplo de uso")
     gr.Markdown("1. Introduce los nombres de las variables y sus niveles en las cajas de texto correspondientes.")
@@ -617,5 +554,7 @@ with gr.Blocks() as demo:
     gr.Markdown("4. Haz clic en 'Ajustar Modelo y Optimizar' para ajustar el modelo y encontrar los niveles óptimos de los factores.")
     gr.Markdown("5. Selecciona una variable fija y su nivel en los controles deslizantes.")
     gr.Markdown("6. Haz clic en 'Generar Gráfico' para generar un gráfico de superficie de respuesta.")
+    gr.Markdown("7. Haz clic en 'Descargar Tablas en Excel' para obtener un archivo Excel con todas las tablas generadas.")
+    gr.Markdown("8. Haz clic en 'Descargar Gráficos en ZIP' para obtener un archivo ZIP con todos los gráficos generados.")
 
 demo.launch()