Update app.py

app.py

@@ -62,7 +62,7 @@ class RSM_BoxBehnken:
         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")
+        return self.model, self.pareto_chart_f(self.model, "Pareto - Modelo Completo (F)"), self.pareto_chart_t(self.model, "Pareto - Modelo Completo (t)")
 
     def fit_simplified_model(self):
         """
@@ -73,8 +73,8 @@ class RSM_BoxBehnken:
         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")
-
+        return self.model_simplified, self.pareto_chart_f(self.model_simplified, "Pareto - Modelo Simplificado (F)"), self.pareto_chart_t(self.model_simplified, "Pareto - Modelo Simplificado (t)")
+    
     def optimize(self, method='Nelder-Mead'):
         """
         Encuentra los niveles óptimos de los factores para maximizar la respuesta usando el modelo simplificado.
@@ -266,18 +266,20 @@ class RSM_BoxBehnken:
         levels = self.get_levels(variable_name)
         return -1 + 2 * (natural_value - levels[0]) / (levels[-1] - levels[0])
 
-    def pareto_chart(self, model, title):
+    def pareto_chart_f(self, model, title):
         """
         Genera un diagrama de Pareto para los efectos usando estadísticos F,
         incluyendo la línea de significancia.
         """
         # Calcular los estadísticos F para cada término
-        # F = (coef/std_err)^2 = t^2
-        fvalues = model.tvalues[1:]**2  # Excluir la Intercept y convertir t a F
+        fvalues = model.fvalues[1:]  # Excluir la Intercept
         abs_fvalues = np.abs(fvalues)
         sorted_idx = np.argsort(abs_fvalues)[::-1]
         sorted_fvalues = abs_fvalues[sorted_idx]
         sorted_names = fvalues.index[sorted_idx]
+        
+        # Cambiar I() por "" en los nombres de los terminos
+        sorted_names = sorted_names.str.replace('I(','').str.replace('**2)','^2').str.replace(' * ', '·')
 
         # Calcular el valor crítico de F para la línea de significancia
         alpha = 0.05  # Nivel de significancia
@@ -301,6 +303,43 @@ class RSM_BoxBehnken:
                      annotation_position="bottom right")
 
         return fig
+    
+    def pareto_chart_t(self, model, title):
+        """
+        Genera un diagrama de Pareto para los efectos usando estadísticos t,
+        incluyendo la línea de significancia.
+        """
+        # Calcular los estadísticos t para cada término
+        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]
+
+        # Cambiar I() por "" en los nombres de los terminos
+        sorted_names = sorted_names.str.replace('I(','').str.replace('**2)','^2').str.replace(' * ', '·')
+
+        # 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.round(3),
+            y=sorted_names,
+            orientation='h',
+            labels={'x': 'Estadístico t', '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"t crítico = {t_critical:.3f}",
+                      annotation_position="bottom right")
+
+        return fig
 
     def get_simplified_equation(self):
         """
@@ -343,81 +382,9 @@ class RSM_BoxBehnken:
 
         return self.data[[self.y_name, 'Predicho', 'Residual']].round(3)
 
-    def calculate_contribution_percentage(self):
+    def calculate_anova_table(self):
         """
-        Calcula el porcentaje de contribución de cada factor usando estadísticos F.
-        """
-        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({
-            'Fuente de Variación': [],
-            'Suma de Cuadrados': [],
-            'Grados de Libertad': [],
-            'Cuadrado Medio': [],
-            'F': [],
-            'Valor p': [],
-            '% Contribución': []
-        })
-
-        # Calcular estadísticos F y porcentaje de contribución para cada factor
-        ms_error = anova_table.loc['Residual', 'sum_sq'] / anova_table.loc['Residual', 'df']
-
-        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']
-                df_factor = row['df']
-                ms_factor = ss_factor / df_factor
-                f_stat = ms_factor / ms_error
-                p_value = f.sf(f_stat, df_factor, anova_table.loc['Residual', 'df'])
-                contribution_percentage = (ss_factor / ss_total) * 100
-
-                contribution_table = pd.concat([contribution_table, pd.DataFrame({
-                    'Fuente de Variación': [factor_name],
-                    'Suma de Cuadrados': [ss_factor],
-                    'Grados de Libertad': [df_factor],
-                    'Cuadrado Medio': [ms_factor],
-                    'F': [f_stat],
-                    'Valor p': [p_value],
-                    '% Contribución': [contribution_percentage]
-                })], ignore_index=True)
-        
-        # Calcular estadístico F global y su valor p
-        f_global = anova_table['sum_sq'][:-1].sum() / anova_table['df'][:-1].sum() / ms_error
-        p_global = f.sf(f_global, anova_table['df'][:-1].sum(), anova_table.loc['Residual', 'df'])
-        
-        # Agregar fila para el estadístico F global
-        contribution_table = pd.concat([contribution_table, pd.DataFrame({
-            'Fuente de Variación': ['F global'],
-            'Suma de Cuadrados': [np.nan],
-            'Grados de Libertad': [np.nan],
-            'Cuadrado Medio': [np.nan],
-            'F': [f_global],
-            'Valor p': [p_global],
-            '% Contribución': [np.nan]
-        })], ignore_index=True)
-
-        return contribution_table.round(3)
-
-    def calculate_detailed_anova(self):
-        """
-        Calcula la tabla ANOVA detallada con la descomposición del error residual.
+        Calcula la tabla ANOVA detallada, incluyendo la contribución porcentual.
         """
         if self.model_simplified is None:
             print("Error: Ajusta el modelo simplificado primero.")
@@ -502,6 +469,9 @@ class RSM_BoxBehnken:
             f_curvature,
             p_curvature
         ]
+        
+        # --- Agregar % de Contribución ---
+        detailed_anova_table['% Contribución'] = (detailed_anova_table['Suma de Cuadrados'] / ss_total) * 100
 
         # Reorganizar las filas y resetear el índice
         detailed_anova_table = detailed_anova_table.reindex([0, 5, 1, 2, 3, 4]).reset_index(drop=True)
@@ -513,13 +483,11 @@ class RSM_BoxBehnken:
         Obtiene todas las tablas generadas para ser exportadas a Excel.
         """
         prediction_table = self.generate_prediction_table()
-        contribution_table = self.calculate_contribution_percentage()
-        detailed_anova_table = self.calculate_detailed_anova()
+        anova_table = self.calculate_anova_table()
 
         return {
             'Predicciones': prediction_table,
-            '% Contribución': contribution_table,
-            'ANOVA Detallada': detailed_anova_table
+            'ANOVA': anova_table,
         }
 
     def save_figures_to_zip(self):
@@ -672,16 +640,15 @@ 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]*11  # Ajustar el número de outputs
+        return [None]*12  # Ajustar el número de outputs
 
     # Ajustar modelos y optimizar
-    model_completo, pareto_completo = rsm.fit_model()
-    model_simplificado, pareto_simplificado = rsm.fit_simplified_model()
+    model_completo, pareto_completo_f, pareto_completo_t = rsm.fit_model()
+    model_simplificado, pareto_simplificado_f, pareto_simplificado_t = 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()
+    anova_table = rsm.calculate_anova_table()
     
     # Generar todas las figuras y almacenarlas
     rsm.generate_all_plots()
@@ -698,13 +665,14 @@ def fit_and_optimize_model():
 
     return (
         model_completo.summary().as_html(),
-        pareto_completo,
+        pareto_completo_f,
+        pareto_completo_t,
         model_simplificado.summary().as_html(),
-        pareto_simplificado,
+        pareto_simplificado_f,
+        pareto_simplificado_t,
         equation_formatted,
         optimization_table,
         prediction_table,
-        contribution_table,
         anova_table,
         zip_path,    # Ruta del ZIP de gráficos
         excel_path   # Ruta del Excel de tablas
@@ -831,16 +799,17 @@ def create_gradio_interface():
                 fit_button = gr.Button("Ajustar Modelo y Optimizar")
                 gr.Markdown("**Modelo Completo**")
                 model_completo_output = gr.HTML()
-                pareto_completo_output = gr.Plot()
+                pareto_completo_f_output = gr.Plot()
+                pareto_completo_t_output = gr.Plot()
                 gr.Markdown("**Modelo Simplificado**")
                 model_simplificado_output = gr.HTML()
-                pareto_simplificado_output = gr.Plot()
+                pareto_simplificado_f_output = gr.Plot()
+                pareto_simplificado_t_output = gr.Plot()
                 gr.Markdown("**Ecuación del Modelo Simplificado**")
                 equation_output = gr.HTML()
                 optimization_table_output = gr.Dataframe(label="Tabla de Optimización", interactive=False)
                 prediction_table_output = gr.Dataframe(label="Tabla de Predicciones", interactive=False)
-                contribution_table_output = gr.Dataframe(label="Tabla de % de Contribución", interactive=False)
-                anova_table_output = gr.Dataframe(label="Tabla ANOVA Detallada", interactive=False)
+                anova_table_output = gr.Dataframe(label="Tabla ANOVA", interactive=False)
                 gr.Markdown("## Descargar Todas las Tablas")
                 download_excel_button = gr.DownloadButton("Descargar Tablas en Excel")
                 download_word_button = gr.DownloadButton("Descargar Tablas en Word")
@@ -874,13 +843,14 @@ def create_gradio_interface():
             inputs=[],
             outputs=[
                 model_completo_output,
-                pareto_completo_output,
+                pareto_completo_f_output,
+                pareto_completo_t_output,
                 model_simplificado_output,
-                pareto_simplificado_output,
+                pareto_simplificado_f_output,
+                pareto_simplificado_t_output,
                 equation_output,
                 optimization_table_output,
                 prediction_table_output,
-                contribution_table_output,
                 anova_table_output,
                 download_all_plots_button,  # Ruta del ZIP de gráficos
                 download_excel_button      # Ruta del Excel de tablas
@@ -961,4 +931,5 @@ def main():
     interface.launch(share=True)
 
 if __name__ == "__main__":
-    main()
+    main()
+