Update app.py

app.py

@@ -8,30 +8,21 @@ 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
-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
+        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.
         """
         self.data = data.copy()
         self.model = None
@@ -39,338 +30,484 @@ class RSM_BoxBehnken:
         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
 
-        # Original levels of variables
+        # Niveles originales de las variables
         self.x1_levels = x1_levels
         self.x2_levels = x2_levels
         self.x3_levels = x3_levels
 
-    def _get_levels(self, variable_name):
+    def get_levels(self, variable_name):
         """
-        Get levels for a specific variable
+        Obtiene los niveles para una variable específica.
         
-        Parameters:
-        -----------
-        variable_name : str
-            Name of the variable
+        Args:
+            variable_name (str): Nombre de la variable.
         
         Returns:
-        --------
-        list
-            Levels of the variable
+            list: Niveles de la 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]
+        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
+        else:
+            raise ValueError(f"Variable desconocida: {variable_name}")
 
-    def fit_model(self, simplified=False):
+    def fit_model(self):
         """
-        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
+        Ajusta el modelo de segundo orden completo a los datos.
         """
-        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:
-            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")
+        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):
+        """
+        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()
+        print("\nModelo Simplificado:")
+        print(self.model_simplified.summary())
+        return self.model_simplified, self.pareto_chart(self.model_simplified, "Pareto - Modelo Simplificado")
 
     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
+        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:
-            raise ValueError("Fit the simplified model first.")
+            print("Error: Ajusta el modelo simplificado primero.")
+            return
 
         def objective_function(x):
-            """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]]
-            }))
+            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
+        # Convertir niveles óptimos de codificados a naturales
         optimal_levels_natural = [
-            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])
+            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)
         ]
-        
+        # Crear la tabla de optimización
         optimization_table = pd.DataFrame({
             'Variable': [self.x1_name, self.x2_name, self.x3_name],
-            'Optimal Level (Natural)': optimal_levels_natural,
-            'Optimal Level (Coded)': [round(x, 3) for x in self.optimal_levels]
+            'Nivel Óptimo (Natural)': optimal_levels_natural,
+            'Nivel Óptimo (Codificado)': self.optimal_levels
         })
 
         return optimization_table
 
-    def coded_to_natural(self, coded_value, variable_name):
+    def plot_rsm_individual(self, fixed_variable, fixed_level):
         """
-        Convert coded value to natural level
-        
-        Parameters:
-        -----------
-        coded_value : float
-            Coded value of the variable
-        variable_name : str
-            Name of the variable
-        
+        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:
-        --------
-        float
-            Natural level of the variable
+            go.Figure: Objeto de figura de Plotly.
         """
-        levels = self._get_levels(variable_name)
-        return levels[0] + (coded_value + 1) * (levels[-1] - levels[0]) / 2
+        if self.model_simplified is None:
+            print("Error: Ajusta el modelo simplificado primero.")
+            return None
 
-    def natural_to_coded(self, natural_value, variable_name):
-        """
-        Convert natural level to coded value
+        # 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]
         
-        Parameters:
-        -----------
-        natural_value : float
-            Natural level of the variable
-        variable_name : str
-            Name of the variable
-        
-        Returns:
-        --------
-        float
-            Coded value of the 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, :],
+                y=y_grid_natural[i, :],
+                z=z_pred[i, :],
+                mode='lines',
+                line=dict(color='gray', width=2),
+                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],
+                y=y_grid_natural[:, j],
+                z=z_pred[:, j],
+                mode='lines',
+                line=dict(color='gray', width=2),
+                showlegend=False,
+                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():
+            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)]),  # Usar colores de la lista
+            text=point_labels,  # Usar las etiquetas creadas
+            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,
+            width=1000,
+            showlegend=True
+        )
+        return fig
+
+    def generate_all_plots(self):
         """
-        levels = self._get_levels(variable_name)
+        Genera todas las gráficas de RSM, variando la variable fija y sus niveles usando el modelo simplificado.
+        """
+        if self.model_simplified is None:
+            print("Error: Ajusta el modelo simplificado primero.")
+            return
+
+        # Niveles naturales para graficar
+        levels_to_plot_natural = {
+            self.x1_name: self.x1_levels,
+            self.x2_name: self.x2_levels,
+            self.x3_name: self.x3_levels
+        }
+
+        # 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()
+
+    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):
         """
-        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
+        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.
         """
-        tvalues = model.tvalues[1:]
+        # Calcular los efectos estandarizados
+        tvalues = model.tvalues[1:]  # Excluir la Intercept
         abs_tvalues = np.abs(tvalues)
         sorted_idx = np.argsort(abs_tvalues)[::-1]
         sorted_tvalues = abs_tvalues[sorted_idx]
         sorted_names = tvalues.index[sorted_idx]
 
-        alpha = 0.05
-        dof = model.df_resid
+        # 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
         t_critical = t.ppf(1 - alpha / 2, dof)
 
+        # Crear el diagrama de Pareto
         fig = px.bar(
             x=sorted_tvalues,
             y=sorted_names,
             orientation='h',
-            labels={'x': 'Standardized Effect', 'y': 'Term'},
+            labels={'x': 'Efecto Estandarizado', 'y': 'Término'},
             title=title
         )
         fig.update_yaxes(autorange="reversed")
+
+        # Agregar la línea de significancia
         fig.add_vline(x=t_critical, line_dash="dot",
-                      annotation_text=f"Critical t = {t_critical:.2f}",
+                      annotation_text=f"t crítico = {t_critical:.2f}",
                       annotation_position="bottom right")
 
         return fig
 
-    def generate_prediction_table(self):
+    def get_simplified_equation(self):
         """
-        Generate prediction table with predicted and residual values
-        
-        Returns:
-        --------
-        pandas.DataFrame
-            Prediction table
+        Imprime la ecuación del modelo simplificado.
         """
         if self.model_simplified is None:
-            raise ValueError("Fit the simplified model first.")
+            print("Error: Ajusta el modelo simplificado primero.")
+            return None
+
+        coefficients = self.model_simplified.params
+        equation = f"{self.y_name} = {coefficients['Intercept']:.4f}"
+
+        for term, coef in coefficients.items():
+            if term != 'Intercept':
+              if term == f'{self.x1_name}':
+                equation += f" + {coef:.4f}*{self.x1_name}"
+              elif term == f'{self.x2_name}':
+                equation += f" + {coef:.4f}*{self.x2_name}"
+              elif term == f'{self.x3_name}':
+                equation += f" + {coef:.4f}*{self.x3_name}"
+              elif term == f'I({self.x1_name} ** 2)':
+                equation += f" + {coef:.4f}*{self.x1_name}^2"
+              elif term == f'I({self.x2_name} ** 2)':
+                equation += f" + {coef:.4f}*{self.x2_name}^2"
+              elif term == f'I({self.x3_name} ** 2)':
+                equation += f" + {coef:.4f}*{self.x3_name}^2"
+
+        return equation
 
-        predictions = self.model_simplified.predict(self.data)
-        residuals = self.data[self.y_name] - predictions
+    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
 
-        prediction_table = self.data.copy()
-        prediction_table['Predicted'] = predictions.round(3)
-        prediction_table['Residual'] = residuals.round(3)
+      self.data['Predicho'] = self.model_simplified.predict(self.data)
+      self.data['Residual'] = self.data[self.y_name] - self.data['Predicho']
 
-        return prediction_table[[self.y_name, 'Predicted', 'Residual']]
+      return self.data[[self.y_name, 'Predicho', 'Residual']]
 
     def calculate_contribution_percentage(self):
-        """
-        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.")
-
-        anova_table = sm.stats.anova_lm(self.model_simplified, typ=2)
-        ss_total = anova_table['sum_sq'].sum()
-
-        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
+      """
+      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
+            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
 
-                contribution_table.append({
-                    'Factor': factor_name,
-                    'Sum of Squares': round(ss_factor, 3),
-                    '% Contribution': round(contribution_percentage, 3)
-                })
+            contribution_table = pd.concat([contribution_table, pd.DataFrame({
+                'Factor': [factor_name],
+                'Suma de Cuadrados': [ss_factor],
+                '% Contribución': [contribution_percentage]
+            })], ignore_index=True)
 
-        return pd.DataFrame(contribution_table)
+      return contribution_table
 
     def calculate_detailed_anova(self):
         """
-        Perform detailed ANOVA analysis
-        
-        Returns:
-        --------
-        pandas.DataFrame
-            Detailed ANOVA table
+        Calcula la tabla ANOVA detallada con la descomposición del error residual.
         """
         if self.model_simplified is None:
-            raise ValueError("Fit the simplified model first.")
+            print("Error: Ajusta el modelo simplificado primero.")
+            return None
 
-        # 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
+        # --- 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)
 
-        # Calcular componentes de variación
-        ss_regression = anova_reduced['sum_sq'][:-1].sum()
+        # 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'
+
+        # 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
 
-        # Error puro
+        # 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]))
 
-        # Falta de ajuste
+        # 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
 
-        # Calcular cuadrados medios y estadísticos F
+        # 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)
+        p_lack_of_fit = 1 - f.cdf(f_lack_of_fit, df_lack_of_fit, df_pure_error) # Usar f.cdf de scipy.stats
 
-        # Crear tabla de ANOVA detallada
+        # 12. Crear la tabla ANOVA detallada
         detailed_anova_table = pd.DataFrame({
-            '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],
-            'p-value': [np.nan, np.nan, round(p_lack_of_fit, 3), np.nan, np.nan]
+            '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],
+            '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]
         })
+        
+        # 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]
+
+        # 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
+
 # --- 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')
+        data = data.apply(pd.to_numeric, errors='coerce')  # Convertir a numérico
 
+        # 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)
 
@@ -390,7 +527,8 @@ 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}"
 
@@ -400,64 +538,8 @@ 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."
-    
-    # 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")
+    fig = rsm.plot_rsm_individual(fixed_variable, fixed_level)
+    return fig
 
 # --- Crear la interfaz de Gradio ---
 
@@ -500,8 +582,6 @@ 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()
@@ -518,7 +598,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.Gallery(label="Gráficos RSM", columns=3, preview=True, height="auto")
+            rsm_plot_output = gr.Plot()
 
     load_button.click(
         load_data,
@@ -527,12 +607,8 @@ 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.")
@@ -541,7 +617,5 @@ 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()