Update app.py

app.py

@@ -6,7 +6,7 @@ import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 from scipy.optimize import minimize
 import plotly.express as px
-from scipy.stats import t
+from scipy.stats import t, f
 import gradio as gr
 
 class RSM_BoxBehnken:
@@ -25,8 +25,6 @@ class RSM_BoxBehnken:
             x3_levels (list): Niveles de la tercera variable independiente.
         """
         self.data = data.copy()
-        # Ya no es necesario renombrar las columnas aquí, se hará al cargar los datos
-
         self.model = None
         self.model_simplified = None
         self.optimized_results = None
@@ -71,7 +69,7 @@ class RSM_BoxBehnken:
         self.model = smf.ols(formula, data=self.data).fit()
         print("Modelo Completo:")
         print(self.model.summary())
-        return self.pareto_chart(self.model, "Pareto - Modelo Completo")
+        return self.model, self.pareto_chart(self.model, "Pareto - Modelo Completo")
 
     def fit_simplified_model(self):
         """
@@ -82,7 +80,7 @@ class RSM_BoxBehnken:
         self.model_simplified = smf.ols(formula, data=self.data).fit()
         print("\nModelo Simplificado:")
         print(self.model_simplified.summary())
-        return self.pareto_chart(self.model_simplified, "Pareto - Modelo Simplificado")
+        return self.model_simplified, self.pareto_chart(self.model_simplified, "Pareto - Modelo Simplificado")
 
     def optimize(self, method='Nelder-Mead'):
         """
@@ -110,12 +108,14 @@ class RSM_BoxBehnken:
             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],
+            'Nivel Óptimo (Natural)': optimal_levels_natural,
+            'Nivel Óptimo (Codificado)': self.optimal_levels
+        })
 
-        print(f"\nNiveles óptimos encontrados (basado en modelo simplificado):")
-        print(f"{self.x1_name}: {optimal_levels_natural[0]:.4f} g/L")
-        print(f"{self.x2_name}: {optimal_levels_natural[1]:.4f} g/L")
-        print(f"{self.x3_name}: {optimal_levels_natural[2]:.4f} g/L")
-        print(f"Valor máximo de {self.y_name}: {-self.optimized_results.fun:.4f}")
+        return optimization_table
 
     def plot_rsm_individual(self, fixed_variable, fixed_level):
         """
@@ -311,6 +311,167 @@ 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}"
+
+        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
+
+    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
+
+      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']]
+
+    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
+            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 = pd.concat([contribution_table, pd.DataFrame({
+                'Factor': [factor_name],
+                'Suma de Cuadrados': [ss_factor],
+                '% Contribución': [contribution_percentage]
+            })], 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'
+
+        # 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
+
+        # 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],
+            '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):
@@ -357,14 +518,22 @@ def load_data(x1_name, x2_name, x3_name, y_name, x1_levels_str, x2_levels_str, x
 
 def fit_and_optimize_model():
     if 'rsm' not in globals():
-        return None, None, "Error: Carga los datos primero."
+        return None, None, None, None, None, None, "Error: Carga los datos primero."
+    
+    model_completo, pareto_completo = rsm.fit_model()
+    model_simplificado, pareto_simplificado = rsm.fit_simplified_model()
+    optimization_table = rsm.optimize()
+    equation = rsm.get_simplified_equation()
+    prediction_table = rsm.generate_prediction_table()
+    contribution_table = rsm.calculate_contribution_percentage()
+    anova_table = rsm.calculate_detailed_anova()
     
-    pareto_completo = rsm.fit_model()
-    pareto_simplificado = rsm.fit_simplified_model()
-    rsm.optimize()
-    model_summary = rsm.model_simplified.summary().as_html()
+    # 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}"
+
     
-    return model_summary, pareto_completo, pareto_simplificado, f"{rsm.x1_name}: {rsm.optimal_levels[0]:.4f}, {rsm.x2_name}: {rsm.optimal_levels[1]:.4f}, {rsm.x3_name}: {rsm.optimal_levels[2]:.4f}, Valor máximo de {rsm.y_name}: {-rsm.optimized_results.fun:.4f}"
+    return model_completo.summary().as_html(), pareto_completo, model_simplificado.summary().as_html(), pareto_simplificado, equation_formatted, optimization_table, prediction_table, contribution_table, anova_table
 
 def generate_rsm_plot(fixed_variable, fixed_level):
     if 'rsm' not in globals():
@@ -413,13 +582,20 @@ with gr.Blocks() as demo:
     with gr.Row(visible=False) as analysis_row:
         with gr.Column():
             fit_button = gr.Button("Ajustar Modelo y Optimizar")
-            model_summary_output = gr.HTML()
-            pareto_chart_completo = gr.Plot()
-            pareto_chart_simplificado = gr.Plot()
-            optimization_results_output = gr.Textbox(label="Resultados de la Optimización")
+            gr.Markdown("**Modelo Completo**")
+            model_completo_output = gr.HTML()
+            pareto_completo_output = gr.Plot()
+            gr.Markdown("**Modelo Simplificado**")
+            model_simplificado_output = gr.HTML()
+            pareto_simplificado_output = gr.Plot()
+            equation_output = gr.HTML()
+            optimization_table_output = gr.Dataframe(label="Tabla de Optimización")
+            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")
         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", "Triptófano"], value="Glucosa")
+            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()