Update app.py

app.py

@@ -11,199 +11,204 @@ import gradio as gr
 import io
 import os
 from zipfile import ZipFile
+import warnings
+
+# Suppress specific warnings
+warnings.filterwarnings('ignore', category=UserWarning)
+warnings.filterwarnings('ignore', category=RuntimeWarning)
 
 class RSM_BoxBehnken:
     def __init__(self, data, x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels):
+        """
+        Initialize the Response Surface Methodology Box-Behnken Design class
+        
+        Parameters:
+        -----------
+        data : pandas.DataFrame
+            Experimental design data
+        x1_name, x2_name, x3_name : str
+            Names of independent variables
+        y_name : str
+            Name of dependent variable
+        x1_levels, x2_levels, x3_levels : list
+            Levels of each independent variable
+        """
         self.data = data.copy()
         self.model = None
         self.model_simplified = None
         self.optimized_results = None
         self.optimal_levels = None
 
+        # Variable names
         self.x1_name = x1_name
         self.x2_name = x2_name
         self.x3_name = x3_name
         self.y_name = y_name
 
-        # Niveles originales de las variables
+        # Original levels of variables
         self.x1_levels = x1_levels
         self.x2_levels = x2_levels
         self.x3_levels = x3_levels
 
-    def get_levels(self, variable_name):
-        if variable_name == self.x1_name:
-            return self.x1_levels
-        elif variable_name == self.x2_name:
-            return self.x2_levels
-        elif variable_name == self.x3_name:
-            return self.x3_levels
+    def _get_levels(self, variable_name):
+        """
+        Get levels for a specific variable
+        
+        Parameters:
+        -----------
+        variable_name : str
+            Name of the variable
+        
+        Returns:
+        --------
+        list
+            Levels of the variable
+        """
+        level_map = {
+            self.x1_name: self.x1_levels,
+            self.x2_name: self.x2_levels,
+            self.x3_name: self.x3_levels
+        }
+        
+        if variable_name not in level_map:
+            raise ValueError(f"Unknown variable: {variable_name}")
+        
+        return level_map[variable_name]
+
+    def fit_model(self, simplified=False):
+        """
+        Fit the response surface model
+        
+        Parameters:
+        -----------
+        simplified : bool, optional
+            Whether to fit a simplified model, by default False
+        
+        Returns:
+        --------
+        tuple
+            Fitted model and Pareto chart
+        """
+        if simplified:
+            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)'
+            self.model_simplified = smf.ols(formula, data=self.data).fit()
+            print("\nSimplified Model:")
+            print(self.model_simplified.summary())
+            return self.model_simplified, self.pareto_chart(self.model_simplified, "Pareto - Simplified Model")
         else:
-            raise ValueError(f"Variable desconocida: {variable_name}")
-
-    def fit_model(self):
-        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}'
-        self.model = smf.ols(formula, data=self.data).fit()
-        print("Modelo Completo:")
-        print(self.model.summary())
-        return self.model, self.pareto_chart(self.model, "Pareto - Modelo Completo")
-
-    def fit_simplified_model(self):
-        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()
-        print("\nModelo Simplificado:")
-        print(self.model_simplified.summary())
-        return self.model_simplified, self.pareto_chart(self.model_simplified, "Pareto - Modelo Simplificado")
+            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}'
+            self.model = smf.ols(formula, data=self.data).fit()
+            print("Full Model:")
+            print(self.model.summary())
+            return self.model, self.pareto_chart(self.model, "Pareto - Full Model")
 
     def optimize(self, method='Nelder-Mead'):
+        """
+        Optimize the response surface model
+        
+        Parameters:
+        -----------
+        method : str, optional
+            Optimization method, by default 'Nelder-Mead'
+        
+        Returns:
+        --------
+        pandas.DataFrame
+            Optimization results table
+        """
         if self.model_simplified is None:
-            print("Error: Ajusta el modelo simplificado primero.")
-            return
+            raise ValueError("Fit the simplified model first.")
 
         def objective_function(x):
-            return -self.model_simplified.predict(pd.DataFrame({self.x1_name: [x[0]], self.x2_name: [x[1]], self.x3_name: [x[2]]}))
+            """Objective function for optimization"""
+            return -self.model_simplified.predict(pd.DataFrame({
+                self.x1_name: [x[0]], 
+                self.x2_name: [x[1]], 
+                self.x3_name: [x[2]]
+            }))
 
         bounds = [(-1, 1), (-1, 1), (-1, 1)]
         x0 = [0, 0, 0]
 
-        self.optimized_results = minimize(objective_function, x0, method=method, bounds=bounds)
+        self.optimized_results = minimize(
+            objective_function, 
+            x0, 
+            method=method, 
+            bounds=bounds
+        )
         self.optimal_levels = self.optimized_results.x
         
+        # Convert to natural levels
         optimal_levels_natural = [
-            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)
+            round(self.coded_to_natural(self.optimal_levels[i], var), 3) 
+            for i, var in enumerate([self.x1_name, self.x2_name, self.x3_name])
         ]
+        
         optimization_table = pd.DataFrame({
             'Variable': [self.x1_name, self.x2_name, self.x3_name],
-            'Nivel Óptimo (Natural)': optimal_levels_natural,
-            'Nivel Óptimo (Codificado)': [round(x, 3) for x in self.optimal_levels]
+            'Optimal Level (Natural)': optimal_levels_natural,
+            'Optimal Level (Coded)': [round(x, 3) for x in self.optimal_levels]
         })
 
         return optimization_table
 
-    def plot_rsm_individual(self, fixed_variable, fixed_level):
-        if self.model_simplified is None:
-            print("Error: Ajusta el modelo simplificado primero.")
-            return None
-
-        varying_variables = [var for var in [self.x1_name, self.x2_name, self.x3_name] if var != fixed_variable]
+    def coded_to_natural(self, coded_value, variable_name):
+        """
+        Convert coded value to natural level
         
-        x_natural_levels = self.get_levels(varying_variables[0])
-        y_natural_levels = self.get_levels(varying_variables[1])
-
-        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)
-
-        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])
-
-        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)
-
-        z_pred = self.model_simplified.predict(prediction_data).values.reshape(x_grid_coded.shape)
-
-        varying_variables = [var for var in [self.x1_name, self.x2_name, self.x3_name] if var != fixed_variable]
-
-        fixed_level_coded = self.natural_to_coded(fixed_level, fixed_variable)
-        subset_data = self.data[np.isclose(self.data[fixed_variable], fixed_level_coded)]
-
-        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)
-        ]
-
-        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]))
-
-        fig = go.Figure(data=[go.Surface(z=z_pred, x=x_grid_natural, y=y_grid_natural, colorscale='Viridis', opacity=0.7, showscale=True)])
-
-        for i in range(x_grid_natural.shape[0]):
-            fig.add_trace(go.Scatter3d(
-                x=x_grid_natural[i, :],
-                y=y_grid_natural[i, :],
-                z=z_pred[i, :],
-                mode='lines',
-                line=dict(color='gray', width=2),
-                showlegend=False,
-                hoverinfo='skip'
-            ))
-        for j in range(x_grid_natural.shape[1]):
-            fig.add_trace(go.Scatter3d(
-                x=x_grid_natural[:, j],
-                y=y_grid_natural[:, j],
-                z=z_pred[:, j],
-                mode='lines',
-                line=dict(color='gray', width=2),
-                showlegend=False,
-                hoverinfo='skip'
-            ))
-
-        colors = ['red', 'blue', 'green', 'purple', 'orange', 'yellow', 'cyan', 'magenta']
-        point_labels = []
-        for i, row in experiments_data.iterrows():
-            point_labels.append(f"{row[self.y_name]:.2f}")
-
-        fig.add_trace(go.Scatter3d(
-            x=experiments_x_natural,
-            y=experiments_y_natural,
-            z=experiments_data[self.y_name],
-            mode='markers+text',
-            marker=dict(size=4, color=colors[:len(experiments_x_natural)]),
-            text=point_labels,
-            textposition='top center',
-            name='Experimentos'
-        ))
-
-        fig.update_layout(
-            scene=dict(
-                xaxis_title=varying_variables[0] + " (g/L)",
-                yaxis_title=varying_variables[1] + " (g/L)",
-                zaxis_title=self.y_name,
-            ),
-            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,
-            width=1000,
-            showlegend=True
-        )
-        return fig
-
-    def generate_all_plots(self):
-        if self.model_simplified is None:
-            print("Error: Ajusta el modelo simplificado primero.")
-            return
-
-        levels_to_plot_natural = {
-            self.x1_name: self.x1_levels,
-            self.x2_name: self.x2_levels,
-            self.x3_name: self.x3_levels
-        }
+        Parameters:
+        -----------
+        coded_value : float
+            Coded value of the variable
+        variable_name : str
+            Name of the variable
         
-        figs = []
-
-        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:
-                    figs.append(fig)
-        return figs
-
-    def coded_to_natural(self, coded_value, variable_name):
-        levels = self.get_levels(variable_name)
+        Returns:
+        --------
+        float
+            Natural level of the variable
+        """
+        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):
-        levels = self.get_levels(variable_name)
+        """
+        Convert natural level to coded value
+        
+        Parameters:
+        -----------
+        natural_value : float
+            Natural level of the variable
+        variable_name : str
+            Name of the variable
+        
+        Returns:
+        --------
+        float
+            Coded value of the variable
+        """
+        levels = self._get_levels(variable_name)
         return -1 + 2 * (natural_value - levels[0]) / (levels[-1] - levels[0])
 
     def pareto_chart(self, model, title):
+        """
+        Create Pareto chart of standardized effects
+        
+        Parameters:
+        -----------
+        model : statsmodels.regression.linear_model.RegressionResultsWrapper
+            Fitted regression model
+        title : str
+            Title of the Pareto chart
+        
+        Returns:
+        --------
+        plotly.graph_objects.Figure
+            Pareto chart
+        """
         tvalues = model.tvalues[1:]
         abs_tvalues = np.abs(tvalues)
         sorted_idx = np.argsort(abs_tvalues)[::-1]
@@ -218,121 +223,107 @@ class RSM_BoxBehnken:
             x=sorted_tvalues,
             y=sorted_names,
             orientation='h',
-            labels={'x': 'Efecto Estandarizado', 'y': 'Término'},
+            labels={'x': 'Standardized Effect', 'y': 'Term'},
             title=title
         )
         fig.update_yaxes(autorange="reversed")
-
         fig.add_vline(x=t_critical, line_dash="dot",
-                      annotation_text=f"t crítico = {t_critical:.2f}",
+                      annotation_text=f"Critical t = {t_critical:.2f}",
                       annotation_position="bottom right")
 
         return fig
 
-    def get_simplified_equation(self):
-        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']:.3f}"
-
-        for term, coef in coefficients.items():
-            if term != 'Intercept':
-              if term == f'{self.x1_name}':
-                equation += f" + {coef:.3f}*{self.x1_name}"
-              elif term == f'{self.x2_name}':
-                equation += f" + {coef:.3f}*{self.x2_name}"
-              elif term == f'{self.x3_name}':
-                equation += f" + {coef:.3f}*{self.x3_name}"
-              elif term == f'I({self.x1_name} ** 2)':
-                equation += f" + {coef:.3f}*{self.x1_name}^2"
-              elif term == f'I({self.x2_name} ** 2)':
-                equation += f" + {coef:.3f}*{self.x2_name}^2"
-              elif term == f'I({self.x3_name} ** 2)':
-                equation += f" + {coef:.3f}*{self.x3_name}^2"
-
-        return equation
-
     def generate_prediction_table(self):
-      if self.model_simplified is None:
-          print("Error: Ajusta el modelo simplificado primero.")
-          return None
+        """
+        Generate prediction table with predicted and residual values
+        
+        Returns:
+        --------
+        pandas.DataFrame
+            Prediction table
+        """
+        if self.model_simplified is None:
+            raise ValueError("Fit the simplified model first.")
 
-      self.data['Predicho'] = self.model_simplified.predict(self.data)
-      self.data['Residual'] = self.data[self.y_name] - self.data['Predicho']
+        predictions = self.model_simplified.predict(self.data)
+        residuals = self.data[self.y_name] - predictions
 
-      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)
+        prediction_table = self.data.copy()
+        prediction_table['Predicted'] = predictions.round(3)
+        prediction_table['Residual'] = residuals.round(3)
 
-      return prediction_table
+        return prediction_table[[self.y_name, 'Predicted', 'Residual']]
 
     def calculate_contribution_percentage(self):
-      if self.model_simplified is None:
-          print("Error: Ajusta el modelo simplificado primero.")
-          return None
-
-      anova_table = sm.stats.anova_lm(self.model_simplified, typ=2)
-      ss_total = anova_table['sum_sq'].sum()
-
-      contribution_table = pd.DataFrame({
-          'Factor': [],
-          'Suma de Cuadrados': [],
-          '% Contribución': []
-      })
-      
-      for index, row in anova_table.iterrows():
-          if index != 'Residual':
-            factor_name = index
-            if factor_name == f'I({self.x1_name} ** 2)':
-              factor_name = f'{self.x1_name}^2'
-            elif factor_name == f'I({self.x2_name} ** 2)':
-              factor_name = f'{self.x2_name}^2'
-            elif factor_name == f'I({self.x3_name} ** 2)':
-              factor_name = f'{self.x3_name}^2'
-            
-            ss_factor = row['sum_sq']
-            contribution_percentage = (ss_factor / ss_total) * 100
+        """
+        Calculate percentage contribution of model terms
+        
+        Returns:
+        --------
+        pandas.DataFrame
+            Contribution percentage table
+        """
+        if self.model_simplified is None:
+            raise ValueError("Fit the simplified model first.")
 
-            contribution_table = pd.concat([contribution_table, pd.DataFrame({
-                'Factor': [factor_name],
-                'Suma de Cuadrados': [round(ss_factor, 3)],
-                '% Contribución': [round(contribution_percentage, 3)]
-            })], ignore_index=True)
+        anova_table = sm.stats.anova_lm(self.model_simplified, typ=2)
+        ss_total = anova_table['sum_sq'].sum()
 
-      return contribution_table
+        contribution_table = []
+        
+        for index, row in anova_table.iterrows():
+            if index != 'Residual':
+                factor_name = index.replace('I(', '').replace('**2)', '^2')
+                ss_factor = row['sum_sq']
+                contribution_percentage = (ss_factor / ss_total) * 100
+
+                contribution_table.append({
+                    'Factor': factor_name,
+                    'Sum of Squares': round(ss_factor, 3),
+                    '% Contribution': round(contribution_percentage, 3)
+                })
+
+        return pd.DataFrame(contribution_table)
 
     def calculate_detailed_anova(self):
+        """
+        Perform detailed ANOVA analysis
+        
+        Returns:
+        --------
+        pandas.DataFrame
+            Detailed ANOVA table
+        """
         if self.model_simplified is None:
-            print("Error: Ajusta el modelo simplificado primero.")
-            return None
+            raise ValueError("Fit the simplified model first.")
 
+        # Preparar datos para ANOVA detallado
+        ss_total = np.sum((self.data[self.y_name] - self.data[self.y_name].mean())**2)
+        df_total = len(self.data) - 1
+
+        # ANOVA para modelo reducido
         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()
-
         anova_reduced = sm.stats.anova_lm(model_reduced, typ=2)
 
-        ss_total = np.sum((self.data[self.y_name] - self.data[self.y_name].mean())**2)
-
-        df_total = len(self.data) - 1
-
+        # Calcular componentes de variación
         ss_regression = anova_reduced['sum_sq'][:-1].sum()
-
         df_regression = len(anova_reduced) - 1
 
         ss_residual = self.model_simplified.ssr
         df_residual = self.model_simplified.df_resid
 
+        # Error puro
         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]))
 
+        # Falta de ajuste
         ss_lack_of_fit = ss_residual - ss_pure_error
         df_lack_of_fit = df_residual - df_pure_error
 
+        # Calcular cuadrados medios y estadísticos F
         ms_regression = ss_regression / df_regression
         ms_residual = ss_residual / df_residual
         ms_lack_of_fit = ss_lack_of_fit / df_lack_of_fit
@@ -341,26 +332,29 @@ class RSM_BoxBehnken:
         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)
 
+        # Crear tabla de ANOVA detallada
         detailed_anova_table = pd.DataFrame({
-            'Fuente de Variación': ['Regresión', 'Residual', 'Falta de Ajuste', 'Error Puro', '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': [round(ms_regression, 3), round(ms_residual, 3), round(ms_lack_of_fit, 3), round(ms_pure_error, 3), np.nan],
+            'Source of Variation': ['Regression', 'Residual', 'Lack of Fit', 'Pure Error', 'Total'],
+            'Sum of Squares': [
+                round(ss_regression, 3), 
+                round(ss_residual, 3), 
+                round(ss_lack_of_fit, 3), 
+                round(ss_pure_error, 3), 
+                round(ss_total, 3)
+            ],
+            'Degrees of Freedom': [df_regression, df_residual, df_lack_of_fit, df_pure_error, df_total],
+            'Mean Square': [
+                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]
+            'p-value': [np.nan, np.nan, round(p_lack_of_fit, 3), np.nan, np.nan]
         })
-        
-        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
-
-        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]
-
-        detailed_anova_table = detailed_anova_table.reindex([0, 5, 1, 2, 3, 4])
-        
-        detailed_anova_table = detailed_anova_table.reset_index(drop=True)
 
         return detailed_anova_table
-
 # --- 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):
@@ -396,7 +390,7 @@ def fit_and_optimize_model():
     prediction_table = rsm.generate_prediction_table()
     contribution_table = rsm.calculate_contribution_percentage()
     anova_table = rsm.calculate_detailed_anova()
-    
+
     equation_formatted = equation.replace(" + ", "<br>+ ").replace(" ** ", "^").replace("*", " × ")
     equation_formatted = f"### Ecuación del Modelo Simplificado:<br>{equation_formatted}"
 
@@ -407,16 +401,19 @@ def generate_rsm_plot(fixed_variable, fixed_level):
     if 'rsm' not in globals():
         return None, "Error: Carga los datos primero."
     
-    # Obtener todas las gráficas
+    # Generar todas las gráficas
     all_figs = rsm.generate_all_plots()
 
-    # Convertir la figura seleccionada a bytes
-    img_bytes = all_figs[0].to_image(format="png")
+    # 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)
 
-    # Devolver la lista de figuras y la imagen en bytes
-    return all_figs, img_bytes
+    # Retornar la lista de imágenes
+    return plot_outputs
 
-# Función para descargar el Excel con todas las tablas
 def download_excel():
     if 'rsm' not in globals():
         return None, "Error: Carga los datos y ajusta el modelo primero."
@@ -425,31 +422,42 @@ def download_excel():
     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='Optimización', index=False)
-        rsm.calculate_contribution_percentage().to_excel(writer, sheet_name='Contribución', 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)
-    
-    # Modificar para usar gr.File
-    return gr.File(value=output, visible=True, filename="resultados_rsm.xlsx")
+    return gr.File.update(value=output, visible=True, filename="resultados_rsm.xlsx")
 
-# Función para descargar las imágenes
 def download_images():
     if 'rsm' not in globals():
         return None, "Error: Carga los datos y ajusta el modelo primero."
 
-    zip_output = io.BytesIO()
-    with ZipFile(zip_output, 'w') as zipf:
-        for fixed_variable in [rsm.x1_name, rsm.x2_name, rsm.x3_name]:
-            for level in rsm.get_levels(fixed_variable):
-                fig = rsm.plot_rsm_individual(fixed_variable, level)
-                img_bytes = fig.to_image(format="png")
-                img_path = f"{fixed_variable}_{level}.png"
-                zipf.writestr(img_path, img_bytes)
+    # Crear un directorio temporal para guardar las imágenes
+    temp_dir = "temp_images"
+    os.makedirs(temp_dir, exist_ok=True)
 
-    zip_output.seek(0)
-    return gr.File(value=zip_output, visible=True, filename="graficos_rsm.zip")
+    # 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 ---
 
@@ -492,6 +500,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()
@@ -503,22 +513,12 @@ with gr.Blocks() as demo:
             prediction_table_output = gr.Dataframe(label="Tabla de Predicciones")
             contribution_table_output = gr.Dataframe(label="Tabla de % de Contribución")
             anova_table_output = gr.Dataframe(label="Tabla ANOVA Detallada")
-            
-            # Botones de descarga
-            with gr.Row():
-                download_excel_button = gr.Button("Descargar Tablas en Excel")
-                download_images_button = gr.Button("Descargar Gráficos en ZIP")
-            excel_file_output = gr.File(label="Descargar Excel")
-            zip_file_output = gr.File(label="Descargar ZIP")
-
         with gr.Column():
             gr.Markdown("## Generar Gráficos de Superficie de Respuesta")
             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")
-            # Usar Gallery para mostrar las imágenes
-            gallery = gr.Gallery(label="Gráficos RSM").style(preview=False, grid=(3,3), height="auto")
-            image_output = gr.Image(label="Descargar Gráfico")
+            rsm_plot_output = gr.Gallery(label="Gráficos RSM", columns=3, preview=True, height="auto")
 
     load_button.click(
         load_data,
@@ -528,11 +528,10 @@ 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=[gallery, image_output])
+    plot_button.click(generate_rsm_plot, inputs=[fixed_variable_input, fixed_level_input], outputs=[rsm_plot_output])
 
-    # Asociar las funciones de descarga a los botones
-    download_excel_button.click(download_excel, outputs=excel_file_output)
-    download_images_button.click(download_images, outputs=zip_file_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")
@@ -542,7 +541,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 .xlsx con todas las tablas generadas.")
-    gr.Markdown("8. Haz clic en 'Descargar Gráficos en ZIP' para obtener un archivo .zip con todas las imágenes de los gráficos.")
+    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()