Update app.py

app.py

@@ -268,35 +268,37 @@ class RSM_BoxBehnken:
 
     def pareto_chart(self, model, title):
         """
-        Genera un diagrama de Pareto para los efectos estandarizados de un modelo,
+        Genera un diagrama de Pareto para los efectos usando estadísticos F,
         incluyendo la línea de significancia.
         """
-        # 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]
+        # 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
+        abs_fvalues = np.abs(fvalues)
+        sorted_idx = np.argsort(abs_fvalues)[::-1]
+        sorted_fvalues = abs_fvalues[sorted_idx]
+        sorted_names = fvalues.index[sorted_idx]
 
-        # Calcular el valor crítico de t para la línea de significancia
+        # Calcular el valor crítico de F 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)
+        dof_num = 1  # Grados de libertad del numerador (cada término)
+        dof_den = model.df_resid  # Grados de libertad residuales
+        f_critical = f.ppf(1 - alpha, dof_num, dof_den)
 
         # Crear el diagrama de Pareto
         fig = px.bar(
-            x=sorted_tvalues.round(3),
+            x=sorted_fvalues.round(3),
             y=sorted_names,
             orientation='h',
-            labels={'x': 'Efecto Estandarizado', 'y': 'Término'},
+            labels={'x': 'Estadístico F', '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")
+        fig.add_vline(x=f_critical, line_dash="dot",
+                     annotation_text=f"F crítico = {f_critical:.3f}",
+                     annotation_position="bottom right")
 
         return fig
 
@@ -327,7 +329,7 @@ class RSM_BoxBehnken:
                     equation += f" + {coef:.3f}*{self.x3_name}^2"
 
         return equation
-
+    
     def generate_prediction_table(self):
         """
         Genera una tabla con los valores actuales, predichos y residuales.
@@ -343,7 +345,7 @@ class RSM_BoxBehnken:
 
     def calculate_contribution_percentage(self):
         """
-        Calcula el porcentaje de contribución de cada factor a la variabilidad de la respuesta (AIA).
+        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.")
@@ -351,18 +353,21 @@ class RSM_BoxBehnken:
 
         # ANOVA del modelo simplificado
         anova_table = sm.stats.anova_lm(self.model_simplified, typ=2)
-
-        # Suma de cuadrados total
+        
+        # Calcular las sumas de cuadrados ajustadas
         ss_total = anova_table['sum_sq'].sum()
-
+        
         # Crear tabla de contribución
         contribution_table = pd.DataFrame({
             'Factor': [],
             'Suma de Cuadrados': [],
+            'Estadístico F': [],
             '% Contribución': []
         })
         
-        # Calcular porcentaje de contribución para cada factor
+        # 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
@@ -374,11 +379,13 @@ class RSM_BoxBehnken:
                     factor_name = f'{self.x3_name}^2'
                 
                 ss_factor = row['sum_sq']
+                f_stat = (ss_factor / row['df']) / ms_error
                 contribution_percentage = (ss_factor / ss_total) * 100
 
                 contribution_table = pd.concat([contribution_table, pd.DataFrame({
                     'Factor': [factor_name],
                     'Suma de Cuadrados': [ss_factor],
+                    'Estadístico F': [f_stat],
                     '% Contribución': [contribution_percentage]
                 })], ignore_index=True)
 
@@ -395,10 +402,10 @@ class RSM_BoxBehnken:
         # --- 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)'
+                         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)
+        # 2. ANOVA del modelo reducido
         anova_reduced = sm.stats.anova_lm(model_reduced, typ=2)
 
         # 3. Suma de cuadrados total
@@ -436,7 +443,10 @@ class RSM_BoxBehnken:
         ms_lack_of_fit = ss_lack_of_fit / df_lack_of_fit if not np.isnan(ss_lack_of_fit) else np.nan
         ms_pure_error = ss_pure_error / df_pure_error if not np.isnan(ss_pure_error) else np.nan
 
-        # 11. Estadístico F y valor p para la falta de ajuste
+        # 11. Estadísticos F y valores p
+        f_regression = ms_regression / ms_residual
+        p_regression = 1 - f.cdf(f_regression, df_regression, df_residual)
+        
         f_lack_of_fit = ms_lack_of_fit / ms_pure_error if not np.isnan(ms_lack_of_fit) else np.nan
         p_lack_of_fit = 1 - f.cdf(f_lack_of_fit, df_lack_of_fit, df_pure_error) if not np.isnan(f_lack_of_fit) else np.nan
 
@@ -446,22 +456,31 @@ class RSM_BoxBehnken:
             '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]
+            'F': [f_regression, np.nan, f_lack_of_fit, np.nan, np.nan],
+            'Valor p': [p_regression, 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)']
+        # Calcular la suma de cuadrados y estadísticos F 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
+        ms_curvature = ss_curvature / df_curvature
+        f_curvature = ms_curvature / ms_residual
+        p_curvature = 1 - f.cdf(f_curvature, df_curvature, df_residual)
 
         # Añadir la fila de curvatura a la tabla ANOVA
-        detailed_anova_table.loc[len(detailed_anova_table)] = ['Curvatura', ss_curvature, df_curvature, ss_curvature / df_curvature, np.nan, np.nan]
+        detailed_anova_table.loc[len(detailed_anova_table)] = [
+            'Curvatura', 
+            ss_curvature, 
+            df_curvature, 
+            ms_curvature,
+            f_curvature,
+            p_curvature
+        ]
 
-        # 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)
+        # Reorganizar las filas y resetear el índice
+        detailed_anova_table = detailed_anova_table.reindex([0, 5, 1, 2, 3, 4]).reset_index(drop=True)
 
         return detailed_anova_table.round(3)
 
@@ -918,4 +937,4 @@ def main():
     interface.launch(share=True)
 
 if __name__ == "__main__":
-    main()
+    main()