Update app.py

app.py

@@ -4,9 +4,10 @@ import pandas as pd
 import statsmodels.formula.api as smf
 import statsmodels.api as sm
 import plotly.graph_objects as go
-from scipy.optimize import minimize
 import plotly.express as px
-from scipy.stats import f
+import plotly.figure_factory as ff
+from scipy.optimize import minimize
+from scipy.stats import f, probplot
 import gradio as gr
 import io
 import zipfile
@@ -15,478 +16,401 @@ from datetime import datetime
 import docx
 from docx.shared import Pt
 from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
-import os
 
-# --- Clase RSM_BoxBehnken (Mejorada) ---
+# --- Clase RSM_BoxBehnken Optimizada y Enriquecida ---
 class RSM_BoxBehnken:
     def __init__(self, data, x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels):
         self.data = data.copy()
-        self.model = None
-        self.model_simplified = None
-        self.optimized_results = None
-        self.optimal_levels = None
-        self.all_figures = []  # Lista para almacenar todas las figuras generadas
-        self.all_tables = {} # Diccionario para almacenar todas las tablas
-        self.x1_name = x1_name
-        self.x2_name = x2_name
-        self.x3_name = x3_name
-        self.y_name = y_name
-        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
-        else: raise ValueError(f"Variable desconocida: {variable_name}")
+        # Nombres y niveles de las variables
+        self.var_names = {'x1': x1_name, 'x2': x2_name, 'x3': x3_name, 'y': y_name}
+        self.levels = {x1_name: x1_levels, x2_name: x2_levels, x3_name: x3_levels}
         
-    def get_units(self, variable_name):
-        units = {'Glucosa': 'g/L', 'Extracto_de_Levadura': 'g/L', 'Triptofano': 'g/L', 'AIA_ppm': 'ppm'}
-        return units.get(variable_name, '')
-
-    def fit_model(self):
-        formula = f'{self.y_name} ~ {self.x1_name} + {self.x2_name} + {self.x3_name} + I({self.x1_name}**2) + I({self.x2_name}**2) + I({self.x3_name}**2) + {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()
-        return self.model, self.pareto_chart(self.model, "Pareto - Modelo Completo")
-
-    def fit_simplified_model(self):
-        # Determinar términos significativos del modelo completo (p < 0.05)
-        pvalues = self.model.pvalues[1:]  # Excluir intercepto
-        significant_terms = pvalues[pvalues < 0.05].index.tolist()
+        # Contenedor para todos los resultados (más organizado)
+        self.results = {
+            'models': {},
+            'tables': {},
+            'plots': {'surface': [], 'diagnostic': {}},
+            'data': {'original': self.data}
+        }
         
-        # Siempre incluir términos lineales y cuadráticos puros si sus interacciones son significativas
-        base_terms = [self.x1_name, self.x2_name, self.x3_name, 
-                      f'I({self.x1_name} ** 2)', f'I({self.x2_name} ** 2)', f'I({self.x3_name} ** 2)']
+    def run_analysis(self, p_threshold=0.05):
+        """Orquesta todo el proceso de análisis."""
+        try:
+            self._fit_full_model()
+            self._fit_simplified_model(p_threshold)
+            
+            if 'simplified' not in self.results['models']:
+                raise ValueError("El modelo simplificado no pudo ser ajustado.")
+
+            # Generar todas las tablas
+            self._optimize()
+            self._generate_prediction_table()
+            self._calculate_detailed_anova()
+            self._calculate_contribution_percentage()
+            
+            # Generar todos los gráficos
+            self._generate_surface_plots()
+            self._generate_diagnostic_plots() # Nueva funcionalidad
+            
+            return True
+        except Exception as e:
+            print(f"Error durante el análisis: {e}")
+            return False
+
+    def _fit_full_model(self):
+        formula = f"`{self.var_names['y']}` ~ `{self.var_names['x1']}` + `{self.var_names['x2']}` + `{self.var_names['x3']}` + " \
+                  f"I(`{self.var_names['x1']}`**2) + I(`{self.var_names['x2']}`**2) + I(`{self.var_names['x3']}`**2) + " \
+                  f"`{self.var_names['x1']}`:`{self.var_names['x2']}` + `{self.var_names['x1']}`:`{self.var_names['x3']}` + `{self.var_names['x2']}`:`{self.var_names['x3']}`"
+        model = smf.ols(formula, data=self.data).fit()
+        self.results['models']['full'] = model
+        self.results['tables']['pareto_full'] = self._create_pareto_chart(model, "Pareto - Modelo Completo")
+
+    def _fit_simplified_model(self, p_threshold=0.05):
+        full_model = self.results['models']['full']
+        pvalues = full_model.pvalues[1:]
+        significant_terms = pvalues[pvalues < p_threshold].index.tolist()
         
-        final_terms = sorted(list(set(base_terms + significant_terms)))
+        # Asegurar que los términos base siempre estén si alguna interacción o cuadrado es significativo
+        base_terms = [f"`{self.var_names[f'x{i}']}`" for i in range(1, 4)] + \
+                     [f"I(`{self.var_names[f'x{i}']}` ** 2)" for i in range(1, 4)]
         
-        formula_simplified = f'{self.y_name} ~ {" + ".join(final_terms)}'
+        final_terms = sorted(list(set(base_terms + significant_terms)))
         
-        self.model_simplified = smf.ols(formula_simplified, data=self.data).fit()
-        return self.model_simplified, self.pareto_chart(self.model_simplified, "Pareto - Modelo Simplificado")
+        if not final_terms:
+            # Si nada es significativo, se usa un modelo con solo el intercepto (modelo medio)
+            formula_simplified = f"`{self.var_names['y']}` ~ 1"
+        else:
+            formula_simplified = f"`{self.var_names['y']}` ~ {' + '.join(final_terms)}"
 
-    def optimize(self, method='Nelder-Mead'):
-        if self.model_simplified is None: return
+        model = smf.ols(formula_simplified, data=self.data).fit()
+        self.results['models']['simplified'] = model
+        self.results['tables']['pareto_simplified'] = self._create_pareto_chart(model, "Pareto - Modelo Simplificado")
+        self.results['tables']['equation'] = self._get_simplified_equation()
+
+    def _optimize(self, method='Nelder-Mead'):
+        model = self.results['models']['simplified']
         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]]})).values[0]
-        
+            df_pred = pd.DataFrame({
+                self.var_names['x1']: [x[0]], self.var_names['x2']: [x[1]], self.var_names['x3']: [x[2]]
+            })
+            return -model.predict(df_pred).iloc[0]
+
         bounds = [(-1, 1), (-1, 1), (-1, 1)]
-        x0 = [0, 0, 0]
-        self.optimized_results = minimize(objective_function, x0, method=method, bounds=bounds)
-        self.optimal_levels = self.optimized_results.x
-        optimal_levels_natural = [self.coded_to_natural(val, name) for val, name in zip(self.optimal_levels, [self.x1_name, self.x2_name, self.x3_name])]
+        opt_results = minimize(objective_function, x0=[0,0,0], method=method, bounds=bounds)
         
-        predicted_max_y = -self.optimized_results.fun
-
-        optimization_table = pd.DataFrame({
-            'Variable': [self.x1_name, self.x2_name, self.x3_name, f'**{self.y_name} (Predicho)**'],
-            'Nivel Óptimo (Natural)': optimal_levels_natural + [f'**{predicted_max_y:.3f}**'],
-            'Nivel Óptimo (Codificado)': list(self.optimal_levels) + ['-']
+        optimal_coded = opt_results.x
+        optimal_natural = [self._coded_to_natural(val, self.var_names[f'x{i+1}']) for i, val in enumerate(optimal_coded)]
+        predicted_max_y = -opt_results.fun
+
+        df = pd.DataFrame({
+            'Variable': [self.var_names['x1'], self.var_names['x2'], self.var_names['x3'], f"**{self.var_names['y']} (Predicho)**"],
+            'Nivel Óptimo (Natural)': optimal_natural + [f"**{predicted_max_y:.4f}**"],
+            'Nivel Óptimo (Codificado)': list(optimal_coded) + ['-']
         })
-        self.all_tables['Optimizacion'] = optimization_table.round(3)
-        return self.all_tables['Optimizacion']
-
-    def plot_rsm_individual(self, fixed_variable, fixed_level):
-        if self.model_simplified is None: return None
-        varying_vars = [v for v in [self.x1_name, self.x2_name, self.x3_name] if v != fixed_variable]
-        x_var, y_var = varying_vars[0], varying_vars[1]
-        
-        x_natural_levels = self.get_levels(x_var)
-        y_natural_levels = self.get_levels(y_var)
+        self.results['tables']['optimization'] = df.round(4)
 
-        x_range = np.linspace(x_natural_levels[0], x_natural_levels[2], 50)
-        y_range = np.linspace(y_natural_levels[0], y_natural_levels[2], 50)
-        x_grid, y_grid = np.meshgrid(x_range, y_range)
+    # --- Métodos de generación de tablas estadísticas (incluyendo los nuevos) ---
 
-        pred_data = pd.DataFrame({
-            x_var: self.natural_to_coded(x_grid.flatten(), x_var),
-            y_var: self.natural_to_coded(y_grid.flatten(), y_var)
-        })
-        pred_data[fixed_variable] = self.natural_to_coded(fixed_level, fixed_variable)
+    def _calculate_detailed_anova(self):
+        model = self.results['models']['simplified']
+        # Error Puro
+        replicates = self.data.groupby([self.var_names['x1'], self.var_names['x2'], self.var_names['x3']]).filter(lambda x: len(x) > 1)
+        df_pure_error = len(replicates) - replicates.nunique().iloc[0] if not replicates.empty else 0
+        ss_pure_error = np.sum(replicates.groupby([self.var_names['x1'], self.var_names['x2'], self.var_names['x3']])[self.var_names['y']].apply(lambda x: np.sum((x - x.mean())**2))) if df_pure_error > 0 else 0
+        ms_pure_error = ss_pure_error / df_pure_error if df_pure_error > 0 else 0
         
-        z_pred = self.model_simplified.predict(pred_data).values.reshape(x_grid.shape)
-
-        fig = go.Figure(data=[go.Surface(z=z_pred, x=x_range, y=y_range, colorscale='Viridis', opacity=0.8)])
-        
-        # Añadir puntos experimentales
-        exp_data = self.data[np.isclose(self.data[fixed_variable], self.natural_to_coded(fixed_level, fixed_variable))]
-        if not exp_data.empty:
-            fig.add_trace(go.Scatter3d(
-                x=self.coded_to_natural(exp_data[x_var], x_var),
-                y=self.coded_to_natural(exp_data[y_var], y_var),
-                z=exp_data[self.y_name],
-                mode='markers',
-                marker=dict(size=5, color='red', symbol='circle'),
-                name='Puntos Experimentales'
-            ))
-
-        fig.update_layout(
-            title=f"{self.y_name} vs {x_var} y {y_var}<br><sup>{fixed_variable} fijo en {fixed_level:.2f} {self.get_units(fixed_variable)}</sup>",
-            scene=dict(xaxis_title=f"{x_var} ({self.get_units(x_var)})",
-                       yaxis_title=f"{y_var} ({self.get_units(y_var)})",
-                       zaxis_title=f"{self.y_name} ({self.get_units(self.y_name)})"),
-            height=600, margin=dict(l=0, r=0, b=0, t=40)
-        )
-        return fig
-
-    def generate_all_plots(self):
-        if self.model_simplified is None: return
-        self.all_figures.clear()
-        variables = [self.x1_name, self.x2_name, self.x3_name]
-        for i in range(3):
-            fixed_variable = variables[i]
-            levels_to_plot = self.get_levels(fixed_variable)
-            for level in levels_to_plot:
-                fig = self.plot_rsm_individual(fixed_variable, level)
-                if fig: self.all_figures.append(fig)
-        return self.all_figures
-
-    def coded_to_natural(self, coded_value, var_name):
-        levels = self.get_levels(var_name)
-        return np.interp(coded_value, [-1, 1], [levels[0], levels[2]])
-
-    def natural_to_coded(self, natural_value, var_name):
-        levels = self.get_levels(var_name)
-        return np.interp(natural_value, [levels[0], levels[2]], [-1, 1])
-
-    def pareto_chart(self, model, title):
-        fvalues = model.tvalues[1:]**2
-        abs_fvalues = np.abs(fvalues)
-        sorted_idx = np.argsort(abs_fvalues)
-        sorted_fvalues = abs_fvalues.iloc[sorted_idx]
-        sorted_names = fvalues.index[sorted_idx]
-        
-        f_critical = f.ppf(1 - 0.05, 1, model.df_resid)
-        
-        fig = px.bar(x=sorted_fvalues, y=sorted_names, orientation='h',
-                     labels={'x': 'Estadístico F', 'y': 'Término del Modelo'}, title=title)
-        fig.add_vline(x=f_critical, line_dash="dot", annotation_text=f"F-crítico ({0.05*100}%) = {f_critical:.2f}")
-        return fig
-
-    def get_simplified_equation(self):
-        if not self.model_simplified: return "N/A"
-        params = self.model_simplified.params
-        eq = f"<b>{self.y_name}</b> = {params['Intercept']:.4f}"
-        for term, coef in params.items():
-            if term == 'Intercept': continue
-            term_name = term.replace('I(', '').replace('**2', '<sup>2</sup>').replace(')', '').replace('_', ' ')
-            sign = "+" if coef >= 0 else "-"
-            eq += f" {sign} {abs(coef):.4f} * {term_name}"
-        return eq
-
-    def generate_prediction_table(self):
-        if self.model_simplified is None: return pd.DataFrame()
-        self.data['Predicho'] = self.model_simplified.predict(self.data)
-        self.data['Residual'] = self.data[self.y_name] - self.data['Predicho']
-        table = self.data[[self.y_name, 'Predicho', 'Residual']].round(3)
-        self.all_tables['Predicciones'] = table
-        return table
-
-    # --- NUEVOS MÉTODOS ESTADÍSTICOS ---
-    def calculate_contribution_percentage(self):
-        if self.model_simplified is None: return pd.DataFrame()
-        anova_table = sm.stats.anova_lm(self.model_simplified, typ=2)
-        anova_table.loc['Residual', 'sum_sq'] = self.model_simplified.ssr
-        anova_table.loc['Residual', 'df'] = self.model_simplified.df_resid
-        ss_total = np.sum((self.data[self.y_name] - self.data[self.y_name].mean())**2)
-        
-        anova_table['% Contribución'] = (anova_table['sum_sq'] / ss_total) * 100
-        
-        # Formatear tabla para presentación
-        contribution = anova_table[['sum_sq', 'df', 'F', 'PR(>F)', '% Contribución']].reset_index()
-        contribution.rename(columns={'index': 'Fuente', 'sum_sq': 'Suma Cuadrados', 'df': 'GL', 'PR(>F)': 'p-valor'}, inplace=True)
-        self.all_tables['Contribucion'] = contribution.round(4)
-        return self.all_tables['Contribucion']
-
-    def calculate_detailed_anova(self):
-        if self.model_simplified is None: return pd.DataFrame()
-        
-        # Calcular Error Puro
-        replicates = self.data.groupby([self.x1_name, self.x2_name, self.x3_name]).filter(lambda x: len(x) > 1)
-        if not replicates.empty:
-            ss_pure_error = np.sum(replicates.groupby([self.x1_name, self.x2_name, self.x3_name])[self.y_name].apply(lambda x: np.sum((x - x.mean())**2)))
-            df_pure_error = len(replicates) - len(replicates.groupby([self.x1_name, self.x2_name, self.x3_name]))
-            ms_pure_error = ss_pure_error / df_pure_error if df_pure_error > 0 else 0
-        else:
-            ss_pure_error, df_pure_error, ms_pure_error = 0, 0, 0
-            
-        ss_residual = self.model_simplified.ssr
-        df_residual = self.model_simplified.df_resid
+        ss_residual, df_residual, ms_residual = model.ssr, model.df_resid, model.mse_resid
         
         ss_lack_of_fit = ss_residual - ss_pure_error
         df_lack_of_fit = df_residual - df_pure_error
         ms_lack_of_fit = ss_lack_of_fit / df_lack_of_fit if df_lack_of_fit > 0 else 0
-        
         f_lack_of_fit = ms_lack_of_fit / ms_pure_error if ms_pure_error > 0 else np.nan
         p_lack_of_fit = f.sf(f_lack_of_fit, df_lack_of_fit, df_pure_error) if ms_pure_error > 0 else np.nan
 
-        # ANOVA del modelo
-        anova_model = sm.stats.anova_lm(self.model_simplified, typ=1)
-        ss_regression = anova_model['sum_sq'].sum()
-        df_regression = anova_model['df'].sum()
-        ms_regression = ss_regression / df_regression
-        ms_residual = ss_residual / df_residual
-        f_regression = ms_regression / ms_residual
-        p_regression = f.sf(f_regression, df_regression, df_residual)
-
-        ss_total = np.sum((self.data[self.y_name] - self.data[self.y_name].mean())**2)
+        ss_total = np.sum((self.data[self.var_names['y']] - self.data[self.var_names['y']].mean())**2)
         df_total = len(self.data) - 1
+        ss_regression = ss_total - ss_residual
+        df_regression = df_total - df_residual
+        ms_regression = ss_regression / df_regression
+        f_regression = model.fvalue
+        p_regression = model.f_pvalue
 
         anova_data = {
-            'Fuente': ['Regresión', 'Error Residual', '  Falta de Ajuste', '  Error Puro', 'Total'],
+            'Fuente': ['Regresión', 'Error Residual', '  Falta de Ajuste', '  Error Puro', 'Total Corregido'],
             'Suma Cuadrados': [ss_regression, ss_residual, ss_lack_of_fit, ss_pure_error, ss_total],
             'GL': [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],
             'Valor F': [f_regression, np.nan, f_lack_of_fit, np.nan, np.nan],
             'p-valor': [p_regression, np.nan, p_lack_of_fit, np.nan, np.nan]
         }
-        detailed_anova_table = pd.DataFrame(anova_data)
-        self.all_tables['ANOVA_Detallada'] = detailed_anova_table.round(4)
-        return self.all_tables['ANOVA_Detallada']
+        self.results['tables']['anova_detailed'] = pd.DataFrame(anova_data).round(4)
+        
+    def _calculate_contribution_percentage(self):
+        model = self.results['models']['simplified']
+        anova_table = sm.stats.anova_lm(model, typ=2)
+        ss_total = np.sum((self.data[self.var_names['y']] - self.data[self.var_names['y']].mean())**2)
+        
+        anova_table['% Contribución'] = (anova_table['sum_sq'] / ss_total) * 100
+        
+        contribution = anova_table[['sum_sq', 'df', 'F', 'PR(>F)', '% Contribución']].reset_index()
+        contribution.rename(columns={'index': 'Fuente', 'sum_sq': 'Suma Cuadrados', 'df': 'GL', 'PR(>F)': 'p-valor'}, inplace=True)
+        self.results['tables']['contribution'] = contribution.round(4)
+        
+    def _generate_prediction_table(self):
+        model = self.results['models']['simplified']
+        self.data['Predicho'] = model.predict(self.data)
+        self.data['Residual'] = self.data[self.var_names['y']] - self.data['Predicho']
+        table = self.data[[self.var_names['y'], 'Predicho', 'Residual']].round(4)
+        self.results['tables']['predictions'] = table
+
+    # --- Métodos de generación de Gráficos (incluyendo los nuevos de diagnóstico) ---
+    
+    def _generate_surface_plots(self):
+        model = self.results['models']['simplified']
+        if not model: return
+        self.results['plots']['surface'].clear()
+        variables = [self.var_names['x1'], self.var_names['x2'], self.var_names['x3']]
+        for i in range(3):
+            fixed_var = variables[i]
+            varying_vars = [v for v in variables if v != fixed_var]
+            x_var, y_var = varying_vars[0], varying_vars[1]
+            
+            for level_coded, level_natural in zip([-1, 0, 1], self.levels[fixed_var]):
+                x_range = np.linspace(self.levels[x_var][0], self.levels[x_var][2], 40)
+                y_range = np.linspace(self.levels[y_var][0], self.levels[y_var][2], 40)
+                x_grid, y_grid = np.meshgrid(x_range, y_range)
+                
+                pred_data = pd.DataFrame({
+                    x_var: self._natural_to_coded(x_grid.flatten(), x_var),
+                    y_var: self._natural_to_coded(y_grid.flatten(), y_var)
+                })
+                pred_data[fixed_var] = level_coded
+                z_pred = model.predict(pred_data).values.reshape(x_grid.shape)
+
+                fig = go.Figure(data=[go.Surface(z=z_pred, x=x_range, y=y_range, colorscale='viridis', opacity=0.9)])
+                
+                fig.update_layout(
+                    title=f"{self.var_names['y']} vs {x_var} & {y_var}<br><sup>{fixed_var} fijo en {level_natural:.2f}</sup>",
+                    scene=dict(xaxis_title=x_var, yaxis_title=y_var, zaxis_title=self.var_names['y']),
+                    height=500, margin=dict(l=0, r=0, b=0, t=40)
+                )
+                self.results['plots']['surface'].append(fig)
+
+    def _generate_diagnostic_plots(self):
+        """Genera un conjunto de gráficos de diagnóstico para los residuales."""
+        model = self.results['models']['simplified']
+        residuals = model.resid
+        fitted = model.fittedvalues
+        
+        # 1. Normal Q-Q Plot
+        qq_data = probplot(residuals, dist="norm", fit=False)
+        qq_fig = px.scatter(x=qq_data[0][0], y=qq_data[0][1], labels={'x': 'Cuantiles Teóricos', 'y': 'Residuales Ordenados'}, title="Gráfico de Probabilidad Normal (Q-Q)")
+        qq_fig.add_shape(type='line', x0=qq_data[0][0].min(), y0=qq_data[1][1], x1=qq_data[0][0].max(), y1=qq_data[1][0]*qq_data[0][0].max()+qq_data[1][1], line=dict(color='red'))
+        self.results['plots']['diagnostic']['qq'] = qq_fig
+
+        # 2. Residuals vs. Fitted
+        rvf_fig = px.scatter(x=fitted, y=residuals, labels={'x': 'Valores Ajustados (Predichos)', 'y': 'Residuales'}, title="Residuales vs. Ajustados")
+        rvf_fig.add_hline(y=0, line_dash="dash", line_color="red")
+        self.results['plots']['diagnostic']['rvf'] = rvf_fig
+
+        # 3. Histogram of Residuals
+        hist_fig = px.histogram(x=residuals, nbins=10, title="Histograma de Residuales")
+        self.results['plots']['diagnostic']['hist'] = hist_fig
+        
+        # 4. Residuals vs. Order
+        run_order = self.data.index
+        rvo_fig = px.line(x=run_order, y=residuals, labels={'x': 'Orden de Ejecución', 'y': 'Residuales'}, title="Residuales vs. Orden de Ejecución", markers=True)
+        rvo_fig.add_hline(y=0, line_dash="dash", line_color="red")
+        self.results['plots']['diagnostic']['rvo'] = rvo_fig
+
+    # --- Métodos de ayuda y exportación ---
+    def _coded_to_natural(self, coded, name): return np.interp(coded, [-1, 1], [self.levels[name][0], self.levels[name][2]])
+    def _natural_to_coded(self, natural, name): return np.interp(natural, [self.levels[name][0], self.levels[name][2]], [-1, 1])
     
-    # --- Funciones de Exportación ---
-    def save_tables_to_excel(self):
-        if not self.all_tables: return None
+    def _create_pareto_chart(self, model, title):
+        if len(model.pvalues) <= 1: return go.Figure().update_layout(title=f"{title}<br><sup>(No hay términos para graficar)</sup>")
+        fvalues = model.tvalues[1:]**2
+        sorted_f = fvalues.sort_values()
+        f_critical = f.ppf(1 - 0.05, 1, model.df_resid)
+        fig = px.bar(x=sorted_f, y=sorted_f.index, orientation='h', labels={'x': 'Estadístico F', 'y': 'Término'}, title=title)
+        fig.add_vline(x=f_critical, line_dash="dot", annotation_text=f"F-crítico (α=0.05) = {f_critical:.2f}")
+        return fig
+
+    def _get_simplified_equation(self):
+        params = self.results['models']['simplified'].params
+        eq = f"<b>{self.var_names['y']}</b> = {params.get('Intercept', 0):.4f}"
+        for term, coef in params.items():
+            if term == 'Intercept': continue
+            term_name = term.replace('`', '').replace('I(', '').replace('**2', '<sup>2</sup>').replace(')', '').replace('_', ' ')
+            sign = "+" if coef >= 0 else "-"
+            eq += f" {sign} {abs(coef):.4f} * <i>{term_name}</i>"
+        return eq.replace("+ -", "- ")
+
+    def export_to_excel(self):
         excel_buffer = io.BytesIO()
         with pd.ExcelWriter(excel_buffer, engine='xlsxwriter') as writer:
-            for sheet_name, table in self.all_tables.items():
-                table.to_excel(writer, sheet_name=sheet_name, index=False)
+            for name, table in self.results['tables'].items():
+                if isinstance(table, pd.DataFrame):
+                    table.to_excel(writer, sheet_name=name.replace('_', ' ').title(), index=False)
         excel_buffer.seek(0)
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx") as temp_file:
-            temp_file.write(excel_buffer.read())
-            return temp_file.name
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx") as f:
+            f.write(excel_buffer.read())
+            return f.name
 
-    def save_figures_to_zip(self):
-        if not self.all_figures: return None
+    def export_all_plots_to_zip(self):
         zip_buffer = io.BytesIO()
-        with zipfile.ZipFile(zip_buffer, 'w') as zip_f:
-            for i, fig in enumerate(self.all_figures):
-                img_bytes = fig.to_image(format="png", width=1000, height=800)
-                zip_f.writestr(f'Grafico_{i+1}.png', img_bytes)
+        with zipfile.ZipFile(zip_buffer, 'w') as zf:
+            for i, fig in enumerate(self.results['plots']['surface']):
+                zf.writestr(f"Surface_Plot_{i+1}.png", fig.to_image(format="png"))
+            for name, fig in self.results['plots']['diagnostic'].items():
+                zf.writestr(f"Diagnostic_{name}.png", fig.to_image(format="png"))
         zip_buffer.seek(0)
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as temp_file:
-            temp_file.write(zip_buffer.read())
-            return temp_file.name
-
-    def export_to_word(self):
-        if not self.all_tables: return None
-        doc = docx.Document()
-        doc.add_heading('Informe de Optimización RSM', 0).alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
-        doc.add_paragraph(f"Generado el: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}").alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
-        
-        for name, table in self.all_tables.items():
-            doc.add_heading(name.replace('_', ' '), level=1)
-            if table.empty:
-                doc.add_paragraph("No hay datos.")
-                continue
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as f:
+            f.write(zip_buffer.read())
+            return f.name
             
-            t = doc.add_table(rows=1, cols=len(table.columns))
-            t.style = 'Table Grid'
-            for j, col_name in enumerate(table.columns):
-                t.cell(0, j).text = str(col_name)
-            for i, row in table.iterrows():
-                row_cells = t.add_row().cells
-                for j, cell_value in enumerate(row):
-                    row_cells[j].text = str(cell_value)
-            doc.add_paragraph()
-
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".docx") as tmp:
-            doc.save(tmp.name)
-            return tmp.name
-            
-# --- Instancia global de la clase ---
+# --- Instancia Global ---
 rsm_analyzer = None
 
-# --- Funciones de la Interfaz Gradio ---
-def process_data(x1, x2, x3, y, l1, l2, l3, data_str):
+# --- Lógica de la Interfaz Gradio ---
+def run_full_analysis(x1, x2, x3, y, l1, l2, l3, data_str):
     global rsm_analyzer
     try:
-        x1_levels = [float(x.strip()) for x in l1.split(',')]
-        x2_levels = [float(x.strip()) for x in l2.split(',')]
-        x3_levels = [float(x.strip()) for x in l3.split(',')]
-        
-        data_io = io.StringIO(data_str)
-        df = pd.read_csv(data_io, header=None)
-        df.columns = ['Exp.', x1, x2, x3, y]
-        df = df.apply(pd.to_numeric, errors='coerce')
-
-        rsm_analyzer = RSM_BoxBehnken(df, x1, x2, x3, y, x1_levels, x2_levels, x3_levels)
-        
-        # Correr análisis
-        model_full, pareto_full = rsm_analyzer.fit_model()
-        model_simp, pareto_simp = rsm_analyzer.fit_simplified_model()
-        opt_table = rsm_analyzer.optimize()
-        equation = rsm_analyzer.get_simplified_equation()
-        pred_table = rsm_analyzer.generate_prediction_table()
-        contrib_table = rsm_analyzer.calculate_contribution_percentage()
-        anova_detail_table = rsm_analyzer.calculate_detailed_anova()
+        x1_l, x2_l, x3_l = [[float(x.strip()) for x in l.split(',')] for l in [l1,l2,l3]]
+        df = pd.read_csv(io.StringIO(data_str), header=None, names=['Exp.', x1, x2, x3, y], quotechar='`')
+        df = df.apply(pd.to_numeric)
         
-        # Generar gráficos
-        all_figs = rsm_analyzer.generate_all_plots()
+        rsm_analyzer = RSM_BoxBehnken(df, x1, x2, x3, y, x1_l, x2_l, x3_l)
+        success = rsm_analyzer.run_analysis()
+        if not success:
+            raise RuntimeError("El análisis falló. Verifique los datos y la configuración.")
         
-        # Preparar salidas
-        initial_plot = all_figs[0] if all_figs else None
-        plot_info = f"Gráfico 1 de {len(all_figs)}" if all_figs else "No hay gráficos"
+        res = rsm_analyzer.results
+        surf_plots = res['plots']['surface']
+        diag_plots = res['plots']['diagnostic']
         
         return (
-            df, gr.update(visible=True), model_full.summary().as_html(), pareto_full,
-            model_simp.summary().as_html(), pareto_simp, equation, opt_table,
-            pred_table, contrib_table, anova_detail_table,
-            initial_plot, plot_info, all_figs, 0
+            df, gr.update(visible=True),
+            # Tab 1: Resumen
+            res['models']['full'].summary().as_html(), res['tables']['pareto_full'],
+            res['models']['simplified'].summary().as_html(), res['tables']['pareto_simplified'],
+            res['tables']['equation'], res['tables']['optimization'],
+            # Tab 2: ANOVA
+            res['tables']['contribution'], res['tables']['anova_detailed'], res['tables']['predictions'],
+            # Tab 3: Diagnostico
+            diag_plots['qq'], diag_plots['rvf'], diag_plots['hist'], diag_plots['rvo'],
+            # Tab 4: Superficies
+            surf_plots[0] if surf_plots else None, f"Gráfico 1 de {len(surf_plots)}", surf_plots, 0
         )
     except Exception as e:
-        gr.Error(f"Error al procesar los datos: {e}")
-        return None, gr.update(visible=False), None, None, None, None, None, None, None, None, None, None, None, [], 0
-
-def navigate_plot(direction, current_index, all_figures):
-    if not all_figures:
-        return None, "No hay gráficos", current_index
-    
-    if direction == 'prev':
-        new_index = (current_index - 1) % len(all_figures)
-    else: # 'next'
-        new_index = (current_index + 1) % len(all_figures)
-    
-    selected_fig = all_figures[new_index]
-    plot_info_text = f"Gráfico {new_index + 1} de {len(all_figures)}"
-    
-    return selected_fig, plot_info_text, new_index
-
-def download_zip():
-    if rsm_analyzer: return rsm_analyzer.save_figures_to_zip()
-    return None
+        gr.Error(f"Error: {e}")
+        return None, gr.update(visible=False), *([None]*16)
 
-def download_excel():
-    if rsm_analyzer: return rsm_analyzer.save_tables_to_excel()
-    return None
+def navigate_plot(direction, idx, figs):
+    if not figs: return None, "No hay gráficos", idx
+    new_idx = (idx + (1 if direction == 'next' else -1)) % len(figs)
+    return figs[new_idx], f"Gráfico {new_idx + 1} de {len(figs)}", new_idx
 
-def download_word():
-    if rsm_analyzer: return rsm_analyzer.export_to_word()
-    return None
-
-# --- Interfaz de Gradio Mejorada ---
+# --- Construcción de la Interfaz Gradio ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🚀 Optimización de Procesos con RSM Box-Behnken")
-    gr.Markdown("Herramienta interactiva para analizar y optimizar diseños experimentales Box-Behnken.")
-
+    gr.Markdown("# 🚀 Optimización Avanzada con RSM Box-Behnken")
+    # ... (resto de la interfaz sin cambios en la definición de componentes)
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("## 1. Configuración del Experimento")
+            gr.Markdown("## 1. Configuración")
             x1_name = gr.Textbox(label="Nombre Var. X1", value="Glucosa")
             x2_name = gr.Textbox(label="Nombre Var. X2", value="Extracto_de_Levadura")
             x3_name = gr.Textbox(label="Nombre Var. X3", value="Triptofano")
             y_name = gr.Textbox(label="Nombre Var. Respuesta (Y)", value="AIA_ppm")
-            
-            with gr.Accordion("Niveles Naturales de las Variables (-1, 0, 1)", open=False):
-                x1_levels = gr.Textbox(label="Niveles de X1 (bajo, medio, alto)", value="1, 3.25, 5.5")
-                x2_levels = gr.Textbox(label="Niveles de X2 (bajo, medio, alto)", value="0.03, 0.165, 0.3")
-                x3_levels = gr.Textbox(label="Niveles de X3 (bajo, medio, alto)", value="0.4, 0.65, 0.9")
-
+            with gr.Accordion("Niveles Naturales (-1, 0, 1)", open=False):
+                x1_levels = gr.Textbox(label="Niveles de X1", value="1, 3.25, 5.5")
+                x2_levels = gr.Textbox(label="Niveles de X2", value="0.03, 0.165, 0.3")
+                x3_levels = gr.Textbox(label="Niveles de X3", value="0.4, 0.65, 0.9")
         with gr.Column(scale=2):
-            gr.Markdown("## 2. Ingrese los Datos Experimentales")
-            data_input = gr.Textbox(
-                label="Pegue los datos (formato CSV: Exp, X1, X2, X3, Y). Los valores de X deben ser codificados (-1, 0, 1).",
-                lines=10,
-                value="""1,-1,-1,0,166.594
-2,1,-1,0,177.557
-3,-1,1,0,127.261
-4,1,1,0,147.573
-5,-1,0,-1,188.883
-6,1,0,-1,224.527
-7,-1,0,1,190.238
-8,1,0,1,226.483
-9,0,-1,-1,195.550
-10,0,1,-1,149.493
-11,0,-1,1,187.683
-12,0,1,1,148.621
-13,0,0,0,278.951
-14,0,0,0,297.238
-15,0,0,0,280.896""")
-            analyze_btn = gr.Button("Analizar Datos", variant="primary")
-    
-    # Esta sección aparece después del análisis
+            gr.Markdown("## 2. Datos Experimentales")
+            data_input = gr.Textbox(label="Pegue datos CSV (Exp, X1, X2, X3, Y). X deben ser codificados (-1, 0, 1).", lines=10, value="""1,-1,-1,0,166.594\n2,1,-1,0,177.557\n3,-1,1,0,127.261\n4,1,1,0,147.573\n5,-1,0,-1,188.883\n6,1,0,-1,224.527\n7,-1,0,1,190.238\n8,1,0,1,226.483\n9,0,-1,-1,195.550\n10,0,1,-1,149.493\n11,0,-1,1,187.683\n12,0,1,1,148.621\n13,0,0,0,278.951\n14,0,0,0,297.238\n15,0,0,0,280.896""")
+            analyze_btn = gr.Button("Analizar y Optimizar", variant="primary")
+
     with gr.Tabs(visible=False) as analysis_tabs:
         with gr.TabItem("📋 Resumen y Optimización"):
-            gr.Markdown("### Tabla de Datos Originales")
-            data_output = gr.DataFrame(label="Datos Cargados")
-            gr.Markdown("### Ecuación del Modelo Simplificado")
-            equation_output = gr.HTML()
-            gr.Markdown("### Niveles Óptimos para Maximizar la Respuesta")
-            optimization_output = gr.DataFrame(label="Optimización")
             with gr.Row():
                 with gr.Column():
-                    gr.Markdown("### Resumen del Modelo Completo")
-                    model_full_output = gr.HTML()
+                    gr.Markdown("### Ecuación del Modelo")
+                    equation_output = gr.HTML()
                 with gr.Column():
-                    gr.Markdown("### Pareto del Modelo Completo")
-                    pareto_full_output = gr.Plot()
+                    gr.Markdown("### Optimización")
+                    optimization_output = gr.DataFrame(label="Niveles Óptimos")
             with gr.Row():
                 with gr.Column():
-                    gr.Markdown("### Resumen del Modelo Simplificado")
-                    model_simp_output = gr.HTML()
+                    gr.Markdown("#### Modelo Completo")
+                    model_full_output = gr.HTML()
+                    pareto_full_output = gr.Plot()
                 with gr.Column():
-                    gr.Markdown("### Pareto del Modelo Simplificado")
+                    gr.Markdown("#### Modelo Simplificado")
+                    model_simp_output = gr.HTML()
                     pareto_simp_output = gr.Plot()
         
-        with gr.TabItem("📊 Análisis de Varianza (ANOVA)"):
-            gr.Markdown("## Tabla de Contribución de Factores")
-            gr.Markdown("Esta tabla muestra qué tan importante es cada término del modelo. Un p-valor bajo (<0.05) indica significancia.")
-            contribution_output = gr.DataFrame(label="% Contribución")
-            gr.Markdown("## ANOVA Detallada del Modelo")
-            gr.Markdown("Esta tabla valida el modelo. Buscamos un p-valor alto (>0.05) para la 'Falta de Ajuste', lo que significa que el modelo se ajusta bien a los datos.")
-            anova_detail_output = gr.DataFrame(label="ANOVA Detallada")
-            gr.Markdown("## Tabla de Predicciones y Residuales")
-            prediction_output = gr.DataFrame(label="Predicciones vs Reales")
-            
+        with gr.TabItem("📊 ANOVA y Contribución"):
+            gr.Markdown("## Tablas de Análisis de Varianza")
+            with gr.Row():
+                with gr.Column(scale=2):
+                    gr.Markdown("### % de Contribución de Factores")
+                    contribution_output = gr.DataFrame()
+                with gr.Column(scale=3):
+                    gr.Markdown("### ANOVA Detallada (Prueba de Falta de Ajuste)")
+                    anova_detail_output = gr.DataFrame()
+            gr.Markdown("### Tabla de Predicciones vs. Valores Reales")
+            prediction_output = gr.DataFrame()
+
+        with gr.TabItem("🔍 Diagnóstico del Modelo"):
+            gr.Markdown("## Análisis de Residuales para Validar Supuestos del Modelo")
+            gr.Markdown("Un buen modelo tendrá residuales que se asemejen al ruido aleatorio. Buscamos puntos cercanos a la línea roja en el Q-Q Plot y sin patrones claros en el gráfico de Residuales vs. Ajustados.")
+            with gr.Row():
+                qq_plot_output = gr.Plot()
+                rvf_plot_output = gr.Plot()
+            with gr.Row():
+                hist_plot_output = gr.Plot()
+                rvo_plot_output = gr.Plot()
+
         with gr.TabItem("📈 Gráficos de Superficie"):
-            gr.Markdown("## Visor de Gráficos de Superficie de Respuesta")
-            gr.Markdown("Navegue a través de todas las combinaciones de variables para visualizar la superficie de respuesta predicha por el modelo.")
+            # ... (sin cambios)
             with gr.Row():
                 prev_btn = gr.Button("⬅️ Anterior")
-                plot_info = gr.Textbox(label="Info del Gráfico", interactive=False, container=False)
+                plot_info = gr.Textbox(label="Info", interactive=False, container=False)
                 next_btn = gr.Button("Siguiente ➡️")
             rsm_plot_output = gr.Plot()
-            # Estados para manejar la navegación de gráficos
-            all_figures_state = gr.State([])
-            current_index_state = gr.State(0)
-
-        with gr.TabItem("📥 Exportar Resultados"):
+        
+        with gr.TabItem("📥 Exportar"):
             gr.Markdown("## Descargar Todos los Resultados")
             with gr.Row():
-                download_excel_btn = gr.DownloadButton("Descargar Tablas (Excel)", variant="secondary")
-                download_word_btn = gr.DownloadButton("Descargar Informe (Word)", variant="secondary")
-                download_zip_btn = gr.DownloadButton("Descargar Gráficos (ZIP)", variant="secondary")
-
-    # --- Lógica de los Eventos ---
+                download_excel_btn = gr.DownloadButton("Tablas (Excel)")
+                download_zip_btn = gr.DownloadButton("Gráficos (ZIP)")
+    
+    # Estados para la navegación de gráficos
+    all_figures_state = gr.State([])
+    current_index_state = gr.State(0)
+
+    # --- Lógica de Eventos ---
+    outputs_list = [
+        data_input, analysis_tabs,
+        model_full_output, pareto_full_output, model_simp_output, pareto_simp_output,
+        equation_output, optimization_output,
+        contribution_output, anova_detail_output, prediction_output,
+        qq_plot_output, rvf_plot_output, hist_plot_output, rvo_plot_output,
+        rsm_plot_output, plot_info, all_figures_state, current_index_state
+    ]
+    
     analyze_btn.click(
-        fn=process_data,
+        fn=run_full_analysis,
         inputs=[x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels, data_input],
-        outputs=[
-            data_output, analysis_tabs, model_full_output, pareto_full_output,
-            model_simp_output, pareto_simp_output, equation_output, optimization_output,
-            prediction_output, contribution_output, anova_detail_output,
-            rsm_plot_output, plot_info, all_figures_state, current_index_state
-        ]
-    )
-
-    prev_btn.click(
-        fn=lambda idx, figs: navigate_plot('prev', idx, figs),
-        inputs=[current_index_state, all_figures_state],
-        outputs=[rsm_plot_output, plot_info, current_index_state]
-    )
-
-    next_btn.click(
-        fn=lambda idx, figs: navigate_plot('next', idx, figs),
-        inputs=[current_index_state, all_figures_state],
-        outputs=[rsm_plot_output, plot_info, current_index_state]
+        outputs=outputs_list
     )
     
-    download_excel_btn.click(fn=download_excel, inputs=[], outputs=[download_excel_btn])
-    download_word_btn.click(fn=download_word, inputs=[], outputs=[download_word_btn])
-    download_zip_btn.click(fn=download_zip, inputs=[], outputs=[download_zip_btn])
-
+    prev_btn.click(lambda i, f: navigate_plot('prev', i, f), [current_index_state, all_figures_state], [rsm_plot_output, plot_info, current_index_state])
+    next_btn.click(lambda i, f: navigate_plot('next', i, f), [current_index_state, all_figures_state], [rsm_plot_output, plot_info, current_index_state])
+    
+    download_excel_btn.click(lambda: rsm_analyzer.export_to_excel() if rsm_analyzer else None, [], download_excel_btn)
+    download_zip_btn.click(lambda: rsm_analyzer.export_all_plots_to_zip() if rsm_analyzer else None, [], download_zip_btn)
 
-# --- Función Principal ---
 if __name__ == "__main__":
     demo.launch(share=True)