Update app.py

app.py

@@ -31,6 +31,9 @@ import matplotlib.pyplot as plt
 from matplotlib.colors import to_hex
 import seaborn as sns
 from statsmodels.stats.outliers_influence import variance_inflation_factor
+import concurrent.futures
+from joblib import Parallel, delayed
+import multiprocessing
 
 # --- Clase RSM_BoxBehnken Mejorada ---
 class RSM_BoxBehnken:
@@ -47,7 +50,6 @@ class RSM_BoxBehnken:
         self.data[f'{x1_name}_{x2_name}'] = self.data[x1_name] * self.data[x2_name]
         self.data[f'{x1_name}_{x3_name}'] = self.data[x1_name] * self.data[x3_name]
         self.data[f'{x2_name}_{x3_name}'] = self.data[x2_name] * self.data[x3_name]
-        
         self.model = None
         self.model_simplified = None
         self.optimized_results = None
@@ -73,19 +75,31 @@ class RSM_BoxBehnken:
             'opacity': 0.7,
             'show_grid': True,
             'show_points': True,
-            'contour_levels': 10
+            'contour_levels': 10,
+            'decimal_places': 3,
+            'pareto_statistic': 'F'  # 't' o 'F'
         }
+        # Para cómputo paralelo
+        self.n_jobs = max(1, multiprocessing.cpu_count() - 1)
     
-    def update_configuration(self, colorscale, opacity, show_grid, show_points, contour_levels):
-        """Actualiza la configuración de visualización"""
+    def update_configuration(self, colorscale, opacity, show_grid, show_points, contour_levels, decimal_places, pareto_statistic):
+        """Actualiza la configuración de visualización y regenera todos los gráficos"""
         self.current_configuration = {
             'colorscale': colorscale,
             'opacity': opacity,
             'show_grid': show_grid,
             'show_points': show_points,
-            'contour_levels': contour_levels
+            'contour_levels': contour_levels,
+            'decimal_places': int(decimal_places),
+            'pareto_statistic': pareto_statistic
         }
-        return "Configuración actualizada correctamente"
+        
+        # Regenerar todos los gráficos con la nueva configuración
+        if self.model_simplified is not None:
+            self.generate_all_plots()
+            self.plot_diagnostics()
+            
+        return "Configuración actualizada correctamente. Todos los gráficos han sido regenerados."
     
     def get_levels(self, variable_name):
         """
@@ -132,20 +146,16 @@ class RSM_BoxBehnken:
         X = self.data[[self.x1_name, self.x2_name, self.x3_name, 
                       f'{self.x1_name}_sq', f'{self.x2_name}_sq', f'{self.x3_name}_sq']]
         y = self.data[self.y_name]
-        
         # Ajustar modelo Ridge
         self.ridge_model = Ridge(alpha=alpha).fit(X, y)
-        
         # Calcular métricas
         r2 = self.ridge_model.score(X, y)
         mse = np.mean((y - self.ridge_model.predict(X))**2)
-        
         # Crear tabla de coeficientes
         coef_df = pd.DataFrame({
             'Variable': X.columns,
             'Coeficiente': self.ridge_model.coef_
         })
-        
         return coef_df, r2, mse
     
     def fit_lasso_regression(self, alpha=0.1):
@@ -157,20 +167,16 @@ class RSM_BoxBehnken:
         X = self.data[[self.x1_name, self.x2_name, self.x3_name, 
                       f'{self.x1_name}_sq', f'{self.x2_name}_sq', f'{self.x3_name}_sq']]
         y = self.data[self.y_name]
-        
         # Ajustar modelo LASSO
         self.lasso_model = Lasso(alpha=alpha, max_iter=10000).fit(X, y)
-        
         # Calcular métricas
         r2 = self.lasso_model.score(X, y)
         mse = np.mean((y - self.lasso_model.predict(X))**2)
-        
         # Crear tabla de coeficientes
         coef_df = pd.DataFrame({
             'Variable': X.columns,
             'Coeficiente': self.lasso_model.coef_
         })
-        
         return coef_df, r2, mse
     
     def fit_elasticnet_regression(self, alpha=0.1, l1_ratio=0.5):
@@ -182,20 +188,16 @@ class RSM_BoxBehnken:
         X = self.data[[self.x1_name, self.x2_name, self.x3_name, 
                       f'{self.x1_name}_sq', f'{self.x2_name}_sq', f'{self.x3_name}_sq']]
         y = self.data[self.y_name]
-        
         # Ajustar modelo ElasticNet
         self.elasticnet_model = ElasticNet(alpha=alpha, l1_ratio=l1_ratio, max_iter=10000).fit(X, y)
-        
         # Calcular métricas
         r2 = self.elasticnet_model.score(X, y)
         mse = np.mean((y - self.elasticnet_model.predict(X))**2)
-        
         # Crear tabla de coeficientes
         coef_df = pd.DataFrame({
             'Variable': X.columns,
             'Coeficiente': self.elasticnet_model.coef_
         })
-        
         return coef_df, r2, mse
     
     def perform_pca(self):
@@ -205,25 +207,20 @@ class RSM_BoxBehnken:
         # Preparar datos
         X = self.data[[self.x1_name, self.x2_name, self.x3_name]]
         X_scaled = StandardScaler().fit_transform(X)
-        
         # Ajustar PCA
         self.pca_model = PCA(n_components=2)
         X_pca = self.pca_model.fit_transform(X_scaled)
-        
         # Crear tabla de resultados
         pca_df = pd.DataFrame(X_pca, columns=['PC1', 'PC2'])
         pca_df[self.y_name] = self.data[self.y_name].values
-        
         # Crear tabla de carga
         loading_df = pd.DataFrame(
             self.pca_model.components_.T,
             columns=['PC1', 'PC2'],
             index=[self.x1_name, self.x2_name, self.x3_name]
         )
-        
         # Varianza explicada
         explained_variance = self.pca_model.explained_variance_ratio_
-        
         return pca_df, loading_df, explained_variance
     
     def plot_pca(self):
@@ -231,10 +228,8 @@ class RSM_BoxBehnken:
         Genera un gráfico de PCA.
         """
         pca_df, loading_df, explained_variance = self.perform_pca()
-        
         # Crear el gráfico
         fig = go.Figure()
-        
         # Puntos de datos
         fig.add_trace(go.Scatter(
             x=pca_df['PC1'], 
@@ -243,14 +238,13 @@ class RSM_BoxBehnken:
             marker=dict(
                 size=10,
                 color=self.data[self.y_name],
-                colorscale='Viridis',
+                colorscale=self.current_configuration['colorscale'],
                 colorbar=dict(title=self.y_name),
                 showscale=True
             ),
-            text=[f"{self.y_name}: {y:.2f}" for y in self.data[self.y_name]],
+            text=[f"{self.y_name}: {y:.{self.current_configuration['decimal_places']}f}" for y in self.data[self.y_name]],
             hoverinfo='text'
         ))
-        
         # Vectores de carga
         for i, var in enumerate([self.x1_name, self.x2_name, self.x3_name]):
             fig.add_trace(go.Scatter(
@@ -260,17 +254,15 @@ class RSM_BoxBehnken:
                 line=dict(width=2),
                 name=var
             ))
-        
         # Configuración del gráfico
         fig.update_layout(
-            title=f'PCA - Varianza Explicada: {explained_variance[0]*100:.1f}% (PC1), {explained_variance[1]*100:.1f}% (PC2)',
+            title=f'PCA - Varianza Explicada: {explained_variance[0]*100:.{self.current_configuration["decimal_places"]}f}% (PC1), {explained_variance[1]*100:.{self.current_configuration["decimal_places"]}f}% (PC2)',
             xaxis_title='Componente Principal 1',
             yaxis_title='Componente Principal 2',
             height=600,
             width=800,
             showlegend=True
         )
-        
         return fig
     
     def optimize(self, method='Nelder-Mead'):
@@ -280,7 +272,6 @@ class RSM_BoxBehnken:
         if self.model_simplified is None:
             print("Error: Ajusta el modelo simplificado primero.")
             return None
-        
         def objective_function(x):
             return -self.model_simplified.predict(pd.DataFrame({
                 self.x1_name: [x[0]],
@@ -290,36 +281,31 @@ class RSM_BoxBehnken:
                 f'{self.x2_name}_sq': [x[1]**2],
                 f'{self.x3_name}_sq': [x[2]**2]
             })).values[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
-        
         # Convertir niveles óptimos de codificados a naturales
         optimal_levels_natural = [
             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],
             'Nivel Óptimo (Natural)': optimal_levels_natural,
             'Nivel Óptimo (Codificado)': self.optimal_levels
         })
-        
-        return optimization_table.round(3)  # Redondear a 3 decimales
+        return optimization_table.round(self.current_configuration['decimal_places'])
     
     def optimize_bayesian(self, n_calls=20):
         """
-        Encuentra los niveles óptimos usando optimización bayesiana.
+        Encuentra los niveles óptimos usando optimización bayesiana con paralelización.
         """
         if self.model_simplified is None:
             print("Error: Ajusta el modelo simplificado primero.")
             return None
-        
         # Definir el espacio de búsqueda
         space = [
             Real(-1, 1, name=self.x1_name),
@@ -339,47 +325,45 @@ class RSM_BoxBehnken:
                 f'{self.x3_name}_sq': [x[2]**2]
             })).values[0]
         
-        # Ejecutar optimización bayesiana
+        # Ejecutar optimización bayesiana con paralelización
         res = gp_minimize(
             objective, 
             space, 
             n_calls=n_calls, 
             random_state=0,
-            n_initial_points=5
+            n_initial_points=5,
+            n_jobs=self.n_jobs  # Paralelización
         )
         
         # Almacenar resultados
         self.optimization_history = res
-        
         # Convertir niveles óptimos de codificados a naturales
         optimal_levels_natural = [
             self.coded_to_natural(res.x[0], self.x1_name),
             self.coded_to_natural(res.x[1], self.x2_name),
             self.coded_to_natural(res.x[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)': res.x
         })
-        
-        # Obtener la figura de convergencia como objeto Figure
+        # Obtener la figura de convergencia
         ax = plot_convergence(res)
         fig = ax.get_figure()
-        
-        return optimization_table.round(3), fig
+        plt.close(fig)  # Cerrar la figura para liberar memoria
+        return optimization_table.round(self.current_configuration['decimal_places']), fig
     
     def optimize_pso(self, n_particles=30, max_iter=50):
         """
-        Encuentra los niveles óptimos usando Particle Swarm Optimization.
+        Encuentra los niveles óptimos usando Particle Swarm Optimization con evaluación paralela.
         """
         if self.model_simplified is None:
             print("Error: Ajusta el modelo simplificado primero.")
             return None
         
-        # Función objetivo
+        # Función objetivo para una partícula
         def objective(x):
             return -self.model_simplified.predict(pd.DataFrame({
                 self.x1_name: [x[0]],
@@ -399,7 +383,11 @@ class RSM_BoxBehnken:
         particles = np.random.uniform(-1, 1, (n_particles, 3))
         velocities = np.random.uniform(-0.1, 0.1, (n_particles, 3))
         personal_best = particles.copy()
-        personal_best_fitness = np.array([objective(p) for p in particles])
+        
+        # Evaluar partículas inicialmente con paralelización
+        with concurrent.futures.ThreadPoolExecutor(max_workers=self.n_jobs) as executor:
+            personal_best_fitness = list(executor.map(objective, particles))
+        personal_best_fitness = np.array(personal_best_fitness)
         
         # Encontrar la mejor partícula global
         global_best_idx = np.argmin(personal_best_fitness)
@@ -411,31 +399,30 @@ class RSM_BoxBehnken:
         
         # Optimización
         for _ in range(max_iter):
+            # Actualizar velocidades y posiciones
             for i in range(n_particles):
-                # Actualizar velocidad
                 r1, r2 = np.random.rand(2)
                 velocities[i] = (w * velocities[i] +
                                 c1 * r1 * (personal_best[i] - particles[i]) +
                                 c2 * r2 * (global_best - particles[i]))
-                
-                # Actualizar posición
                 particles[i] += velocities[i]
-                
-                # Asegurar que esté dentro de los límites
                 particles[i] = np.clip(particles[i], -1, 1)
-                
-                # Evaluar nueva posición
-                fitness = objective(particles[i])
-                
-                # Actualizar mejor personal
-                if fitness < personal_best_fitness[i]:
-                    personal_best[i] = particles[i].copy()
-                    personal_best_fitness[i] = fitness
-                
-                # Actualizar mejor global
-                if fitness < global_best_fitness:
-                    global_best = particles[i].copy()
-                    global_best_fitness = fitness
+            
+            # Evaluar nuevas posiciones con paralelización
+            with concurrent.futures.ThreadPoolExecutor(max_workers=self.n_jobs) as executor:
+                fitness_values = list(executor.map(objective, particles))
+            fitness_values = np.array(fitness_values)
+            
+            # Actualizar mejores valores
+            improved = fitness_values < personal_best_fitness
+            personal_best[improved] = particles[improved]
+            personal_best_fitness[improved] = fitness_values[improved]
+            
+            # Actualizar mejor global
+            if np.min(fitness_values) < global_best_fitness:
+                global_best_idx = np.argmin(fitness_values)
+                global_best = particles[global_best_idx].copy()
+                global_best_fitness = fitness_values[global_best_idx]
             
             # Almacenar estado actual para visualización
             history.append({
@@ -450,17 +437,14 @@ class RSM_BoxBehnken:
             self.coded_to_natural(global_best[1], self.x2_name),
             self.coded_to_natural(global_best[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)': global_best
         })
-        
         # Crear gráfico de la evolución
         fig = go.Figure()
-        
         # Añadir trayectorias de partículas
         for i in range(0, len(history), max(1, len(history)//10)):
             for j in range(n_particles):
@@ -474,7 +458,6 @@ class RSM_BoxBehnken:
                         showlegend=False,
                         hoverinfo='skip'
                     ))
-        
         # Añadir posición final de partículas
         fig.add_trace(go.Scatter3d(
             x=history[-1]['particles'][:, 0],
@@ -484,7 +467,6 @@ class RSM_BoxBehnken:
             marker=dict(size=4, color='blue'),
             name='Partículas finales'
         ))
-        
         # Añadir mejor solución global
         fig.add_trace(go.Scatter3d(
             x=[global_best[0]],
@@ -494,7 +476,6 @@ class RSM_BoxBehnken:
             marker=dict(size=6, color='red'),
             name='Mejor solución'
         ))
-        
         fig.update_layout(
             scene=dict(
                 xaxis_title=self.x1_name,
@@ -504,8 +485,7 @@ class RSM_BoxBehnken:
             title='Evolución de la Optimización con PSO',
             height=700
         )
-        
-        return optimization_table.round(3), fig
+        return optimization_table.round(self.current_configuration['decimal_places']), fig
     
     def calculate_vif(self):
         """
@@ -514,16 +494,13 @@ class RSM_BoxBehnken:
         if self.model_simplified is None:
             print("Error: Ajusta el modelo simplificado primero.")
             return None
-        
         # Variables predictoras
         X = self.data[[self.x1_name, self.x2_name, self.x3_name, 
                       f'{self.x1_name}_sq', f'{self.x2_name}_sq', f'{self.x3_name}_sq']]
-        
         # Calcular VIF para cada variable
         vif_data = pd.DataFrame()
         vif_data["Variable"] = X.columns
         vif_data["VIF"] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]
-        
         return vif_data
     
     def plot_diagnostics(self):
@@ -533,13 +510,11 @@ class RSM_BoxBehnken:
         if self.model_simplified is None:
             print("Error: Ajusta el modelo simplificado primero.")
             return []
-        
         # Calcular residuos y valores ajustados
         fitted = self.model_simplified.fittedvalues
         residuals = self.model_simplified.resid
         standardized_residuals = residuals / np.sqrt(self.model_simplified.mse_resid)
         leverage = self.model_simplified.get_influence().hat_matrix_diag
-        
         # 1. Residuos vs Valores Ajustados
         fig1 = go.Figure()
         fig1.add_trace(go.Scatter(
@@ -554,17 +529,15 @@ class RSM_BoxBehnken:
         ))
         fig1.add_hline(y=0, line_dash="dash", line_color="red")
         fig1.update_layout(
-            title='Residuos vs Valores Ajustados',
+            title=f'Residuos vs Valores Ajustados ({self.current_configuration["decimal_places"]} decimales)',
             xaxis_title='Valores Ajustados',
             yaxis_title='Residuos',
             height=400
         )
-        
         # 2. Q-Q Plot
         sorted_residuals = np.sort(residuals)
         n = len(sorted_residuals)
         theoretical_quantiles = t.ppf(np.arange(0.5, n)/n, df=self.model_simplified.df_resid)
-        
         fig2 = go.Figure()
         fig2.add_trace(go.Scatter(
             x=theoretical_quantiles,
@@ -587,12 +560,11 @@ class RSM_BoxBehnken:
             name='Línea de referencia'
         ))
         fig2.update_layout(
-            title='Q-Q Plot de Residuos',
+            title=f'Q-Q Plot de Residuos ({self.current_configuration["decimal_places"]} decimales)',
             xaxis_title='Cuantiles Teóricos',
             yaxis_title='Cuantiles de Residuos',
             height=400
         )
-        
         # 3. Gráfico de Influencia (Leverage vs Residuos Estándar)
         fig3 = go.Figure()
         fig3.add_trace(go.Scatter(
@@ -613,15 +585,13 @@ class RSM_BoxBehnken:
                       line_dash="dash", line_color="green", 
                       annotation_text="Límite Leverage")
         fig3.update_layout(
-            title='Gráfico de Influencia (Leverage vs Residuos Estándar)',
+            title=f'Gráfico de Influencia ({self.current_configuration["decimal_places"]} decimales)',
             xaxis_title='Leverage',
             yaxis_title='Residuos Estándar',
             height=400
         )
-        
         # 4. Gráfico de Escala-Localización
         sqrt_abs_standardized_residuals = np.sqrt(np.abs(standardized_residuals))
-        
         fig4 = go.Figure()
         fig4.add_trace(go.Scatter(
             x=fitted,
@@ -634,12 +604,11 @@ class RSM_BoxBehnken:
             )
         ))
         fig4.update_layout(
-            title='Gráfico de Escala-Localización',
+            title=f'Gráfico de Escala-Localización ({self.current_configuration["decimal_places"]} decimales)',
             xaxis_title='Valores Ajustados',
             yaxis_title='√|Residuos Estándar|',
             height=400
         )
-        
         self.diagnostic_figures = [fig1, fig2, fig3, fig4]
         return self.diagnostic_figures
     
@@ -650,59 +619,47 @@ class RSM_BoxBehnken:
         if self.model_simplified is None:
             print("Error: Ajusta el modelo simplificado primero.")
             return None
-        
         # Preparar datos
         X = self.data[[self.x1_name, self.x2_name, self.x3_name, 
                       f'{self.x1_name}_sq', f'{self.x2_name}_sq', f'{self.x3_name}_sq']]
         y = self.data[self.y_name]
-        
         # Crear los folds
         kf = KFold(n_splits=cv_folds, shuffle=True, random_state=42)
-        
         # Almacenar los resultados
         r2_scores = []
         mse_scores = []
-        
         # Realizar la validación cruzada
         for train_index, test_index in kf.split(X):
             X_train, X_test = X.iloc[train_index], X.iloc[test_index]
             y_train, y_test = y.iloc[train_index], y.iloc[test_index]
-            
             # Crear un DataFrame para el ajuste del modelo
             train_data = X_train.copy()
             train_data[self.y_name] = y_train
-            
             # Ajustar el modelo en los datos de entrenamiento
             formula = f'{self.y_name} ~ {self.x1_name} + {self.x2_name} + {self.x3_name} + ' \
                       f'{self.x1_name}_sq + {self.x2_name}_sq + {self.x3_name}_sq'
             model = smf.ols(formula, data=train_data).fit()
-            
             # Predecir en los datos de prueba
             y_pred = model.predict(X_test)
-            
             # Calcular R²
             ss_total = np.sum((y_test - np.mean(y_test))**2)
             ss_residual = np.sum((y_test - y_pred)**2)
             r2 = 1 - (ss_residual / ss_total)
             r2_scores.append(r2)
-            
             # Calcular MSE
             mse = np.mean((y_test - y_pred)**2)
             mse_scores.append(mse)
-        
         # Crear tabla de resultados
         cv_results = pd.DataFrame({
             'Fold': range(1, cv_folds+1),
             'R²': r2_scores,
             'MSE': mse_scores
         })
-        
         # Agregar promedio
         cv_results.loc['Promedio'] = ['Promedio', np.mean(r2_scores), np.mean(mse_scores)]
-        
         return cv_results
     
-    def plot_contour_individual(self, fixed_variable, fixed_level, contour_levels=10):
+    def plot_contour_individual(self, fixed_variable, fixed_level, contour_levels=None):
         """
         Genera un gráfico de contorno para una configuración específica.
         """
@@ -710,22 +667,21 @@ class RSM_BoxBehnken:
             print("Error: Ajusta el modelo simplificado primero.")
             return None
         
+        if contour_levels is None:
+            contour_levels = self.current_configuration['contour_levels']
+        
         # 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]
-        
         # 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(),
@@ -736,28 +692,22 @@ class RSM_BoxBehnken:
         prediction_data[f'{varying_variables[0]}_sq'] = prediction_data[varying_variables[0]] ** 2
         prediction_data[f'{varying_variables[1]}_sq'] = prediction_data[varying_variables[1]] ** 2
         prediction_data[f'{fixed_variable}_sq'] = prediction_data[fixed_variable] ** 2
-        
         # Calcular los valores predichos
         z_pred = self.model_simplified.predict(prediction_data).values.reshape(x_grid_coded.shape)
-        
         # 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)]
-        
         # 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 contorno
         fig = go.Figure()
-        
         # Añadir contornos
         fig.add_trace(go.Contour(
             x=x_grid_natural,
@@ -773,7 +723,6 @@ class RSM_BoxBehnken:
             ),
             colorbar=dict(title=self.y_name)
         ))
-        
         # Añadir puntos de experimentos
         fig.add_trace(go.Scatter(
             x=experiments_x_natural,
@@ -784,19 +733,17 @@ class RSM_BoxBehnken:
                 color='red',
                 symbol='circle'
             ),
-            text=[f"{y:.3f}" for y in experiments_data[self.y_name]],
+            text=[f"{y:.{self.current_configuration['decimal_places']}f}" for y in experiments_data[self.y_name]],
             hoverinfo='text'
         ))
-        
         # Añadir etiquetas y título
         fig.update_layout(
-            title=f"{self.y_name} vs {varying_variables[0]} y {varying_variables[1]}<br><sup>{fixed_variable} fijo en {fixed_level:.3f} ({self.get_units(fixed_variable)}) (Modelo Simplificado)</sup>",
+            title=f"{self.y_name} vs {varying_variables[0]} y {varying_variables[1]}<br><sup>{fixed_variable} fijo en {fixed_level:.{self.current_configuration['decimal_places']}f} ({self.get_units(fixed_variable)}) (Modelo Simplificado)</sup>",
             xaxis_title=f"{varying_variables[0]} ({self.get_units(varying_variables[0])})",
             yaxis_title=f"{varying_variables[1]} ({self.get_units(varying_variables[1])})",
             height=600,
             width=800
         )
-        
         return fig
     
     def plot_rsm_individual(self, fixed_variable, fixed_level):
@@ -806,23 +753,18 @@ class RSM_BoxBehnken:
         if self.model_simplified is None:
             print("Error: Ajusta el modelo simplificado primero.")
             return None
-        
         # 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]
-        
         # 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(),
@@ -833,25 +775,20 @@ class RSM_BoxBehnken:
         prediction_data[f'{varying_variables[0]}_sq'] = prediction_data[varying_variables[0]] ** 2
         prediction_data[f'{varying_variables[1]}_sq'] = prediction_data[varying_variables[1]] ** 2
         prediction_data[f'{fixed_variable}_sq'] = prediction_data[fixed_variable] ** 2
-        
         # Calcular los valores predichos
         z_pred = self.model_simplified.predict(prediction_data).values.reshape(x_grid_coded.shape)
-        
         # 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)]
-        
         # 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, 
@@ -861,7 +798,6 @@ class RSM_BoxBehnken:
             opacity=self.current_configuration['opacity'], 
             showscale=True
         )])
-        
         # --- Añadir cuadrícula a la superficie si está habilitado ---
         if self.current_configuration['show_grid']:
             # Líneas en la dirección x
@@ -887,22 +823,20 @@ class RSM_BoxBehnken:
                     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
         if self.current_configuration['show_points']:
             colors = px.colors.qualitative.Safe
-            point_labels = [f"{row[self.y_name]:.3f}" for _, row in experiments_data.iterrows()]
+            point_labels = [f"{row[self.y_name]:.{self.current_configuration['decimal_places']}f}" for _, row in experiments_data.iterrows()]
             fig.add_trace(go.Scatter3d(
                 x=experiments_x_natural,
                 y=experiments_y_natural,
-                z=experiments_data[self.y_name].round(3),
+                z=experiments_data[self.y_name].round(self.current_configuration['decimal_places']),
                 mode='markers+text',
                 marker=dict(size=4, color=colors[:len(experiments_x_natural)]),
                 text=point_labels,
                 textposition='top center',
                 name='Experimentos'
             ))
-        
         # Añadir etiquetas y título con variables naturales
         fig.update_layout(
             scene=dict(
@@ -910,12 +844,11 @@ class RSM_BoxBehnken:
                 yaxis_title=f"{varying_variables[1]} ({self.get_units(varying_variables[1])})",
                 zaxis_title=self.y_name,
             ),
-            title=f"{self.y_name} vs {varying_variables[0]} y {varying_variables[1]}<br><sup>{fixed_variable} fijo en {fixed_level:.3f} ({self.get_units(fixed_variable)}) (Modelo Simplificado)</sup>",
+            title=f"{self.y_name} vs {varying_variables[0]} y {varying_variables[1]}<br><sup>{fixed_variable} fijo en {fixed_level:.{self.current_configuration['decimal_places']}f} ({self.get_units(fixed_variable)}) (Modelo Simplificado)</sup>",
             height=800,
             width=1000,
             showlegend=True
         )
-        
         return fig
     
     def get_units(self, variable_name):
@@ -939,16 +872,13 @@ class RSM_BoxBehnken:
         if self.model_simplified is None:
             print("Error: Ajusta el modelo simplificado primero.")
             return
-        
         self.all_figures = []  # Resetear la lista de figuras
-        
         # 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 almacenar 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]:
@@ -968,38 +898,50 @@ class RSM_BoxBehnken:
     
     def pareto_chart(self, model, title):
         """
-        Genera un diagrama de Pareto para los efectos usando estadísticos F,
+        Genera un diagrama de Pareto para los efectos usando estadísticos t o 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
-        abs_fvalues = np.abs(fvalues)
-        sorted_idx = np.argsort(abs_fvalues)[::-1]
-        sorted_fvalues = abs_fvalues[sorted_idx]
-        sorted_names = fvalues.index[sorted_idx]
+        statistic_type = self.current_configuration['pareto_statistic']
+        
+        # Calcular los estadísticos según la selección
+        if statistic_type == 'F':
+            # Usar estadístico F (t^2)
+            fvalues = model.tvalues[1:]**2  # Excluir la Intercept y convertir t a F
+            values = np.abs(fvalues)
+            y_label = 'Estadístico F'
+        else:
+            # Usar estadístico t directamente
+            tvalues = model.tvalues[1:]  # Excluir la Intercept
+            values = np.abs(tvalues)
+            y_label = 'Estadístico t'
         
-        # Calcular el valor crítico de F para la línea de significancia
+        sorted_idx = np.argsort(values)[::-1]
+        sorted_values = values[sorted_idx]
+        sorted_names = values.index[sorted_idx]
+        
+        # Calcular el valor crítico para la línea de significancia
         alpha = 0.05  # Nivel de significancia
-        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)
+        if statistic_type == 'F':
+            dof_num = 1  # Grados de libertad del numerador (cada término)
+            dof_den = model.df_resid  # Grados de libertad residuales
+            critical_value = f.ppf(1 - alpha, dof_num, dof_den)
+        else:
+            dof = model.df_resid
+            critical_value = t.ppf(1 - alpha/2, dof)  # Valor crítico para prueba de dos colas
         
         # Crear el diagrama de Pareto
         fig = px.bar(
-            x=sorted_fvalues.round(3),
+            x=sorted_values.round(self.current_configuration['decimal_places']),
             y=sorted_names,
             orientation='h',
-            labels={'x': 'Estadístico F', 'y': 'Término'},
+            labels={'x': y_label, 'y': 'Término'},
             title=title
         )
         fig.update_yaxes(autorange="reversed")
-        
         # Agregar la línea de significancia
-        fig.add_vline(x=f_critical, line_dash="dot",
-                     annotation_text=f"F crítico = {f_critical:.3f}",
+        fig.add_vline(x=critical_value, line_dash="dot",
+                     annotation_text=f"{statistic_type.upper()} crítico = {critical_value:.{self.current_configuration['decimal_places']}f}",
                      annotation_position="bottom right")
-        
         return fig
     
     def get_simplified_equation(self):
@@ -1009,24 +951,22 @@ class RSM_BoxBehnken:
         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']:.3f}"
+        equation = f"{self.y_name} = {coefficients['Intercept']:.{self.current_configuration['decimal_places']}f}"
         for term, coef in coefficients.items():
             if term != 'Intercept':
                 if term == f'{self.x1_name}':
-                    equation += f" + {coef:.3f}*{self.x1_name}"
+                    equation += f" + {coef:.{self.current_configuration['decimal_places']}f}*{self.x1_name}"
                 elif term == f'{self.x2_name}':
-                    equation += f" + {coef:.3f}*{self.x2_name}"
+                    equation += f" + {coef:.{self.current_configuration['decimal_places']}f}*{self.x2_name}"
                 elif term == f'{self.x3_name}':
-                    equation += f" + {coef:.3f}*{self.x3_name}"
+                    equation += f" + {coef:.{self.current_configuration['decimal_places']}f}*{self.x3_name}"
                 elif term == f'{self.x1_name}_sq':
-                    equation += f" + {coef:.3f}*{self.x1_name}^2"
+                    equation += f" + {coef:.{self.current_configuration['decimal_places']}f}*{self.x1_name}^2"
                 elif term == f'{self.x2_name}_sq':
-                    equation += f" + {coef:.3f}*{self.x2_name}^2"
+                    equation += f" + {coef:.{self.current_configuration['decimal_places']}f}*{self.x2_name}^2"
                 elif term == f'{self.x3_name}_sq':
-                    equation += f" + {coef:.3f}*{self.x3_name}^2"
-        
+                    equation += f" + {coef:.{self.current_configuration['decimal_places']}f}*{self.x3_name}^2"
         return equation
     
     def generate_prediction_table(self):
@@ -1036,11 +976,9 @@ class RSM_BoxBehnken:
         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']].round(3)
+        return self.data[[self.y_name, 'Predicho', 'Residual']].round(self.current_configuration['decimal_places'])
     
     def calculate_contribution_percentage(self):
         """
@@ -1049,13 +987,10 @@ class RSM_BoxBehnken:
         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': [],
@@ -1066,10 +1001,8 @@ class RSM_BoxBehnken:
             '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']
-        
         # Agregar fila para el bloque
         block_ss = self.data.groupby('Exp.')[self.y_name].sum().var() * len(self.data)
         block_df = 1
@@ -1086,7 +1019,6 @@ class RSM_BoxBehnken:
             'Valor p': [block_p],
             '% Contribución': [block_contribution]
         })], ignore_index=True)
-        
         # Agregar fila para el modelo
         model_ss = anova_table['sum_sq'][:-1].sum()  # Suma todo excepto residual
         model_df = anova_table['df'][:-1].sum()
@@ -1103,7 +1035,6 @@ class RSM_BoxBehnken:
             'Valor p': [model_p],
             '% Contribución': [model_contribution]
         })], ignore_index=True)
-        
         # Agregar filas para cada término del modelo
         for index, row in anova_table.iterrows():
             if index != 'Residual':
@@ -1129,7 +1060,6 @@ class RSM_BoxBehnken:
                     'Valor p': [p_value],
                     '% Contribución': [contribution_percentage]
                 })], ignore_index=True)
-        
         # Agregar fila para Cor Total
         cor_total_ss = ss_total
         cor_total_df = len(self.data) - 1
@@ -1142,8 +1072,7 @@ class RSM_BoxBehnken:
             'Valor p': [np.nan],
             '% Contribución': [100]
         })], ignore_index=True)
-        
-        return contribution_table.round(3)
+        return contribution_table.round(self.current_configuration['decimal_places'])
     
     def calculate_detailed_anova(self):
         """
@@ -1152,32 +1081,24 @@ class RSM_BoxBehnken:
         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'{self.x1_name}_sq + {self.x2_name}_sq + {self.x3_name}_sq'
         model_reduced = smf.ols(formula_reduced, data=self.data).fit()
-        
         # 2. ANOVA del modelo reducido
         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)]
         if not replicas.empty:
@@ -1186,23 +1107,19 @@ class RSM_BoxBehnken:
         else:
             ss_pure_error = np.nan
             df_pure_error = np.nan
-        
         # 9. Suma de cuadrados de la falta de ajuste
         ss_lack_of_fit = ss_residual - ss_pure_error if not np.isnan(ss_pure_error) else np.nan
         df_lack_of_fit = df_residual - df_pure_error if not np.isnan(df_pure_error) else np.nan
-        
         # 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 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í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
-        
         # 12. Crear la tabla ANOVA detallada
         detailed_anova_table = pd.DataFrame({
             'Fuente de Variación': ['Regresión', 'Residual', 'Falta de Ajuste', 'Error Puro', 'Total'],
@@ -1212,7 +1129,6 @@ class RSM_BoxBehnken:
             '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 estadísticos F para la curvatura
         ss_curvature = anova_reduced['sum_sq'][f'{self.x1_name}_sq'] + \
                       anova_reduced['sum_sq'][f'{self.x2_name}_sq'] + \
@@ -1221,7 +1137,6 @@ class RSM_BoxBehnken:
         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', 
@@ -1231,11 +1146,9 @@ class RSM_BoxBehnken:
             f_curvature,
             p_curvature
         ]
-        
         # 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)
+        return detailed_anova_table.round(self.current_configuration['decimal_places'])
     
     def get_all_tables(self):
         """
@@ -1354,7 +1267,6 @@ class RSM_BoxBehnken:
             doc.save(tmp.name)
             tmp_path = tmp.name
         return tmp_path
-
 # --- Funciones para la Interfaz de Gradio Mejorada ---
 def load_data(x1_name, x2_name, x3_name, y_name, x1_levels_str, x2_levels_str, x3_levels_str, data_str):
     """
@@ -1376,14 +1288,14 @@ def load_data(x1_name, x2_name, x3_name, y_name, x1_levels_str, x2_levels_str, x
         # 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)
-        return data.round(3), x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels, True
+        return data.round(rsm.current_configuration['decimal_places']), x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels, True
     except Exception as e:
         # Mostrar mensaje de error
         error_message = f"Error al cargar los datos: {str(e)}"
         print(error_message)
         return None, "", "", "", "", [], [], [], False
 
-def fit_and_optimize_model(regularization_alpha=1.0, regularization_l1_ratio=0.5):
+def fit_and_optimize_model(regularization_alpha=1.0, regularization_l1_ratio=0.5, decimal_places=3, pareto_statistic='F'):
     if 'rsm' not in globals():
         # Devolver None para todos los componentes de salida
         return (
@@ -1392,10 +1304,13 @@ def fit_and_optimize_model(regularization_alpha=1.0, regularization_l1_ratio=0.5
             None, None, None, None, None
         )
     
+    # Actualizar configuración de decimales y estadístico de Pareto
+    rsm.current_configuration['decimal_places'] = int(decimal_places)
+    rsm.current_configuration['pareto_statistic'] = pareto_statistic
+    
     # Ajustar modelos y optimizar
     model_completo, pareto_completo = rsm.fit_model()
     model_simplificado, pareto_simplificado = rsm.fit_simplified_model()
-    
     # Ajustar modelos de regularización
     ridge_coef, ridge_r2, ridge_mse = rsm.fit_ridge_regression(alpha=regularization_alpha)
     lasso_coef, lasso_r2, lasso_mse = rsm.fit_lasso_regression(alpha=regularization_alpha)
@@ -1403,39 +1318,32 @@ def fit_and_optimize_model(regularization_alpha=1.0, regularization_l1_ratio=0.5
         alpha=regularization_alpha, 
         l1_ratio=regularization_l1_ratio
     )
-    
     optimization_table = rsm.optimize()
     bayesian_opt_table, bayesian_plot = rsm.optimize_bayesian()
     pso_opt_table, pso_plot = rsm.optimize_pso()
-    
     equation = rsm.get_simplified_equation()
     prediction_table = rsm.generate_prediction_table()
     contribution_table = rsm.calculate_contribution_percentage()
     anova_table = rsm.calculate_detailed_anova()
     cross_val_table = rsm.calculate_cross_validation()
     vif_table = rsm.calculate_vif()
-    
     # Generar todas las figuras y almacenarlas
     rsm.generate_all_plots()
     diagnostic_plots = rsm.plot_diagnostics()
-    
     # 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}"
-    
     # Formatear métricas de regularización
     regularization_metrics = f"""
     ### Métricas de Modelos de Regularización:
-    - **Ridge Regression**: R² = {ridge_r2:.4f}, MSE = {ridge_mse:.4f}
-    - **LASSO Regression**: R² = {lasso_r2:.4f}, MSE = {lasso_mse:.4f}
-    - **ElasticNet**: R² = {elasticnet_r2:.4f}, MSE = {elasticnet_mse:.4f}
+    - **Ridge Regression**: R² = {ridge_r2:.{decimal_places}f}, MSE = {ridge_mse:.{decimal_places}f}
+    - **LASSO Regression**: R² = {lasso_r2:.{decimal_places}f}, MSE = {lasso_mse:.{decimal_places}f}
+    - **ElasticNet**: R² = {elasticnet_r2:.{decimal_places}f}, MSE = {elasticnet_mse:.{decimal_places}f}
     """
-    
     # Guardar las tablas en Excel temporal
     excel_path = rsm.save_tables_to_excel()
     # Guardar todas las figuras en un ZIP temporal
     zip_path = rsm.save_figures_to_zip()
-    
     return (
         model_completo.summary().as_html(),
         pareto_completo,
@@ -1537,14 +1445,13 @@ def exportar_word(rsm_instance, tables_dict):
         return word_path
     return None
 
-def update_visualization_settings(colorscale, opacity, show_grid, show_points, contour_levels):
+def update_visualization_settings(colorscale, opacity, show_grid, show_points, contour_levels, decimal_places, pareto_statistic):
     """
-    Actualiza la configuración de visualización.
+    Actualiza la configuración de visualización y regenera todos los gráficos.
     """
     if 'rsm' not in globals():
         return "Error: Primero cargue los datos"
-    
-    message = rsm.update_configuration(colorscale, opacity, show_grid, show_points, contour_levels)
+    message = rsm.update_configuration(colorscale, opacity, show_grid, show_points, contour_levels, decimal_places, pareto_statistic)
     return message
 
 def generate_contour_plot(fixed_variable, fixed_level, contour_levels):
@@ -1553,7 +1460,6 @@ def generate_contour_plot(fixed_variable, fixed_level, contour_levels):
     """
     if 'rsm' not in globals():
         return None
-    
     return rsm.plot_contour_individual(fixed_variable, fixed_level, contour_levels)
 
 # --- Crear la interfaz de Gradio Mejorada ---
@@ -1568,18 +1474,15 @@ def create_gradio_interface():
         técnicas avanzadas de optimización.
         </div>
         """)
-        
         # Estado para el índice actual de gráficos
         current_index_state = gr.State(0)
         all_figures_state = gr.State([])
         diagnostic_figures_state = gr.State([])
-        
         # Pestañas principales
         with gr.Tabs():
             # Pestaña 1: Configuración y Carga de Datos
             with gr.Tab("1. Configuración y Carga de Datos", id="tab1"):
                 gr.Markdown("### 📥 Configuración del Diseño Experimental")
-                
                 # Asistente de progreso
                 with gr.Row():
                     progress = gr.Markdown("""
@@ -1590,7 +1493,6 @@ def create_gradio_interface():
                         <span style="min-width: 70px; text-align: right; color: #666;">20% Completado</span>
                     </div>
                     """)
-                
                 with gr.Row():
                     with gr.Column(scale=2):
                         gr.Markdown("#### 🔤 Nombres de Variables")
@@ -1600,7 +1502,6 @@ def create_gradio_interface():
                             - **Variable Dependiente**: Variable de respuesta que desea optimizar
                             - Use nombres sin espacios o guiones bajos en su lugar (ej: 'Temperatura', 'pH')
                             """)
-                        
                         x1_name_input = gr.Textbox(label="Variable X1 (ej. Glucosa)", value="Glucosa", 
                                                  info="Nombre de la primera variable independiente")
                         x2_name_input = gr.Textbox(label="Variable X2 (ej. Extracto_de_Levadura)", value="Extracto_de_Levadura",
@@ -1609,7 +1510,6 @@ def create_gradio_interface():
                                                  info="Nombre de la tercera variable independiente")
                         y_name_input = gr.Textbox(label="Variable Dependiente (ej. AIA_ppm)", value="AIA_ppm",
                                                 info="Nombre de la variable de respuesta")
-                    
                     with gr.Column(scale=3):
                         gr.Markdown("#### 📊 Niveles de Factores")
                         with gr.Accordion("Ayuda para niveles de factores", open=False):
@@ -1618,7 +1518,6 @@ def create_gradio_interface():
                             - El orden debe ser: nivel bajo, nivel central, nivel alto
                             - Ejemplo: 1, 3.5, 5.5
                             """)
-                        
                         with gr.Row():
                             x1_levels_input = gr.Textbox(label="Niveles de X1", value="1, 3.5, 5.5",
                                                        info="Niveles para la variable X1 (bajo, central, alto)")
@@ -1626,7 +1525,6 @@ def create_gradio_interface():
                                                        info="Niveles para la variable X2 (bajo, central, alto)")
                             x3_levels_input = gr.Textbox(label="Niveles de X3", value="0.4, 0.65, 0.9",
                                                        info="Niveles para la variable X3 (bajo, central, alto)")
-                
                 gr.Markdown("#### 📤 Datos del Experimento")
                 with gr.Accordion("Formato de datos requerido", open=False):
                     gr.Markdown("""
@@ -1640,7 +1538,6 @@ def create_gradio_interface():
                       ...
                       ```
                     """)
-                
                 data_input = gr.Textbox(label="Datos del Experimento (formato CSV)", lines=10, 
                                       value="""1,-1,-1,0,166.594
 2,1,-1,0,177.557
@@ -1657,18 +1554,14 @@ def create_gradio_interface():
 13,0,0,0,278.951
 14,0,0,0,297.238
 15,0,0,0,280.896""")
-                
                 with gr.Row():
                     load_button = gr.Button("Cargar Datos 📂", variant="primary")
                     data_output = gr.Dataframe(label="Datos Cargados", interactive=False)
-                
                 gr.Markdown("#### ✅ Estado de Carga")
                 status_output = gr.Textbox(label="Estado", value="Esperando para cargar datos...", interactive=False)
-            
             # Pestaña 2: Análisis Estadístico
             with gr.Tab("2. Análisis Estadístico", id="tab2"):
                 gr.Markdown("### 📈 Análisis Estadístico del Modelo")
-                
                 # Asistente de progreso
                 with gr.Row():
                     progress2 = gr.Markdown("""
@@ -1679,12 +1572,21 @@ def create_gradio_interface():
                         <span style="min-width: 70px; text-align: right; color: #666;">40% Completado</span>
                     </div>
                     """)
-                
                 with gr.Row():
                     with gr.Column(scale=2):
                         gr.Markdown("#### ⚙️ Configuración del Análisis")
-                        
-                        with gr.Accordion("Parámetros de regularización", open=True):
+                        with gr.Accordion("Parámetros de análisis", open=True):
+                            decimal_places = gr.Slider(
+                                minimum=0, maximum=5, value=3, step=1,
+                                label="Número de decimales",
+                                info="Número de decimales a mostrar en los resultados"
+                            )
+                            pareto_statistic = gr.Radio(
+                                ["t", "F"], 
+                                value="F", 
+                                label="Estadístico para diagrama de Pareto",
+                                info="Seleccionar el estadístico a utilizar en los diagramas de Pareto"
+                            )
                             regularization_alpha = gr.Slider(
                                 minimum=0.001, maximum=10.0, value=1.0, step=0.1,
                                 label="Parámetro Alpha (Regularización)",
@@ -1695,9 +1597,7 @@ def create_gradio_interface():
                                 label="Proporción L1 (ElasticNet)",
                                 info="0 = Ridge, 1 = LASSO, 0.5 = ElasticNet"
                             )
-                        
                         fit_button = gr.Button("Ejecutar Análisis Estadístico 📊", variant="primary")
-                        
                         gr.Markdown("#### 📊 Resultados Básicos")
                         model_completo_output = gr.HTML(label="Modelo Completo")
                         pareto_completo_output = gr.Plot(label="Diagrama de Pareto - Modelo Completo")
@@ -1705,10 +1605,8 @@ def create_gradio_interface():
                         pareto_simplificado_output = gr.Plot(label="Diagrama de Pareto - Modelo Simplificado")
                         equation_output = gr.HTML(label="Ecuación del Modelo Simplificado")
                         prediction_table_output = gr.Dataframe(label="Tabla de Predicciones", interactive=False)
-                    
                     with gr.Column(scale=3):
                         gr.Markdown("#### 📐 Modelos Avanzados")
-                        
                         with gr.Tabs():
                             with gr.Tab("Regularización"):
                                 gr.Markdown("### Resultados de Modelos de Regularización")
@@ -1720,7 +1618,6 @@ def create_gradio_interface():
                                         lasso_coef_output = gr.Dataframe(label="Coeficientes LASSO")
                                     with gr.Column():
                                         elasticnet_coef_output = gr.Dataframe(label="Coeficientes ElasticNet")
-                            
                             with gr.Tab("Diagnóstico"):
                                 gr.Markdown("### Gráficos de Diagnóstico del Modelo")
                                 with gr.Row():
@@ -1729,17 +1626,14 @@ def create_gradio_interface():
                                 with gr.Row():
                                     diagnostic_plot3 = gr.Plot(label="Gráfico de Influencia")
                                     diagnostic_plot4 = gr.Plot(label="Gráfico de Escala-Localización")
-                            
                             with gr.Tab("ANOVA y Contribución"):
                                 gr.Markdown("### Análisis de Varianza y Contribución")
                                 anova_table_output = gr.Dataframe(label="Tabla ANOVA Detallada", interactive=False)
                                 contribution_table_output = gr.Dataframe(label="Tabla de % de Contribución", interactive=False)
                                 vif_table_output = gr.Dataframe(label="Factor de Inflación de Varianza (VIF)", interactive=False)
-            
             # Pestaña 3: Visualización
             with gr.Tab("3. Visualización", id="tab3"):
                 gr.Markdown("### 🖼️ Visualización de Superficies de Respuesta")
-                
                 # Asistente de progreso
                 with gr.Row():
                     progress3 = gr.Markdown("""
@@ -1750,11 +1644,9 @@ def create_gradio_interface():
                         <span style="min-width: 70px; text-align: right; color: #666;">60% Completado</span>
                     </div>
                     """)
-                
                 with gr.Row():
                     with gr.Column(scale=2):
                         gr.Markdown("#### ⚙️ Configuración de Visualización")
-                        
                         with gr.Accordion("Personalización de Gráficos", open=True):
                             colorscale = gr.Dropdown(
                                 choices=['Viridis', 'Plasma', 'Inferno', 'Magma', 'Cividis', 'Turbo', 'Rainbow', 'Portland'],
@@ -1765,10 +1657,19 @@ def create_gradio_interface():
                             show_grid = gr.Checkbox(value=True, label="Mostrar Cuadrícula")
                             show_points = gr.Checkbox(value=True, label="Mostrar Puntos Experimentales")
                             contour_levels = gr.Slider(minimum=5, maximum=20, value=10, step=1, label="Niveles de Contorno")
-                            
+                            decimal_places_vis = gr.Slider(
+                                minimum=0, maximum=5, value=3, step=1,
+                                label="Número de decimales en gráficos",
+                                info="Número de decimales a mostrar en los gráficos"
+                            )
+                            pareto_statistic_vis = gr.Radio(
+                                ["t", "F"], 
+                                value="F", 
+                                label="Estadístico para diagrama de Pareto",
+                                info="Seleccionar el estadístico a utilizar en los diagramas de Pareto"
+                            )
                             update_vis_btn = gr.Button("Actualizar Configuración de Visualización", variant="secondary")
                             vis_status = gr.Textbox(label="Estado", value="Configuración predeterminada", interactive=False)
-                        
                         gr.Markdown("#### 🔍 Selección de Gráfico")
                         with gr.Accordion("Ayuda para selección de gráficos", open=False):
                             gr.Markdown("""
@@ -1776,7 +1677,6 @@ def create_gradio_interface():
                             - **Nivel de Variable Fija**: Valor específico de la variable fija
                             - Puede generar múltiples gráficos para diferentes combinaciones
                             """)
-                        
                         fixed_variable_input = gr.Dropdown(
                             label="Variable Fija", 
                             choices=["Glucosa", "Extracto_de_Levadura", "Triptofano"], 
@@ -1791,35 +1691,27 @@ def create_gradio_interface():
                             value="Superficie 3D", 
                             label="Tipo de Gráfico"
                         )
-                        
                         with gr.Row():
                             plot_button = gr.Button("Generar Gráficos 📊", variant="primary")
                             contour_button = gr.Button("Generar Contorno 📈", variant="secondary")
-                    
                     with gr.Column(scale=3):
                         gr.Markdown("#### 📊 Visualización de Resultados")
-                        
                         with gr.Tabs():
                             with gr.Tab("Superficie 3D"):
                                 with gr.Row():
                                     left_button = gr.Button("❮", variant="secondary")
                                     right_button = gr.Button("❯", variant="secondary")
-                                
                                 rsm_plot_output = gr.Plot(label="Superficie de Respuesta")
                                 plot_info = gr.Textbox(label="Información del Gráfico", value="Gráfico 1 de 9", interactive=False)
-                                
                                 with gr.Row():
                                     download_plot_button = gr.DownloadButton("Descargar Gráfico Actual (PNG) 📥")
                                     download_all_plots_button = gr.DownloadButton("Descargar Todos los Gráficos (ZIP) 📦")
-                            
                             with gr.Tab("Contorno"):
                                 contour_plot_output = gr.Plot(label="Gráfico de Contorno")
                                 download_contour_button = gr.DownloadButton("Descargar Contorno (PNG) 📥")
-            
             # Pestaña 4: Optimización
             with gr.Tab("4. Optimización", id="tab4"):
                 gr.Markdown("### 🎯 Optimización de la Respuesta")
-                
                 # Asistente de progreso
                 with gr.Row():
                     progress4 = gr.Markdown("""
@@ -1830,11 +1722,9 @@ def create_gradio_interface():
                         <span style="min-width: 70px; text-align: right; color: #666;">80% Completado</span>
                     </div>
                     """)
-                
                 with gr.Row():
                     with gr.Column(scale=2):
                         gr.Markdown("#### ⚙️ Configuración de Optimización")
-                        
                         with gr.Accordion("Métodos de Optimización", open=True):
                             optimization_method = gr.Radio(
                                 ["Nelder-Mead", "Bayesiana", "PSO", "Todos"], 
@@ -1844,39 +1734,31 @@ def create_gradio_interface():
                             n_calls = gr.Slider(minimum=10, maximum=50, value=20, step=5, label="Llamadas (Opt. Bayesiana)")
                             n_particles = gr.Slider(minimum=10, maximum=50, value=30, step=5, label="Partículas (PSO)")
                             max_iter = gr.Slider(minimum=10, maximum=100, value=50, step=10, label="Iteraciones (PSO)")
-                        
                         optimize_button = gr.Button("Ejecutar Optimización 🔍", variant="primary")
-                        
                         gr.Markdown("#### 📊 Resultados de Optimización")
                         optimization_table_output = gr.Dataframe(label="Tabla de Optimización (Nelder-Mead)", interactive=False)
                         bayesian_opt_table_output = gr.Dataframe(label="Tabla de Optimización (Bayesiana)", interactive=False)
                         pso_opt_table_output = gr.Dataframe(label="Tabla de Optimización (PSO)", interactive=False)
                         bayesian_plot_output = gr.Plot(label="Convergencia de Optimización Bayesiana")
                         pso_plot_output = gr.Plot(label="Visualización de Optimización PSO")
-                    
                     with gr.Column(scale=3):
                         gr.Markdown("#### 📈 Análisis Adicional de Optimización")
-                        
                         with gr.Tabs():
                             with gr.Tab("Análisis de Sensibilidad"):
                                 gr.Markdown("### Análisis de Sensibilidad de los Factores")
                                 # Aquí se podrían agregar gráficos de sensibilidad
                                 gr.Plot(label="Gráfico de Sensibilidad")
                                 gr.Dataframe(label="Tabla de Sensibilidad")
-                            
                             with gr.Tab("Intervalos de Confianza"):
                                 gr.Markdown("### Intervalos de Confianza para la Predicción Óptima")
                                 gr.Plot(label="Intervalos de Confianza")
                                 gr.Dataframe(label="Valores de Confianza")
-                            
                             with gr.Tab("Validación Cruzada"):
                                 gr.Markdown("### Resultados de Validación Cruzada")
                                 cross_val_table_output = gr.Dataframe(label="Resultados de Validación Cruzada", interactive=False)
-            
             # Pestaña 5: Reporte y Exportación
             with gr.Tab("5. Reporte y Exportación", id="tab5"):
                 gr.Markdown("### 📑 Generación de Reportes y Exportación de Resultados")
-                
                 # Asistente de progreso
                 with gr.Row():
                     progress5 = gr.Markdown("""
@@ -1887,11 +1769,9 @@ def create_gradio_interface():
                         <span style="min-width: 70px; text-align: right; color: #666;">100% Completado</span>
                     </div>
                     """)
-                
                 with gr.Row():
                     with gr.Column(scale=2):
                         gr.Markdown("#### 📤 Opciones de Exportación")
-                        
                         with gr.Accordion("Configuración del Reporte", open=True):
                             report_title = gr.Textbox(
                                 label="Título del Reporte", 
@@ -1908,13 +1788,11 @@ def create_gradio_interface():
                                 label="Incluir Tablas en el Reporte",
                                 info="Incluirá todas las tablas estadísticas en el documento"
                             )
-                        
                         gr.Markdown("#### 📎 Formatos de Exportación")
                         with gr.Row():
                             download_excel_button = gr.DownloadButton("Descargar Tablas en Excel 📊", variant="secondary")
                             download_word_button = gr.DownloadButton("Descargar Reporte en Word 📝", variant="primary")
                             download_ppt_button = gr.DownloadButton("Descargar Presentación en PowerPoint 💼", variant="secondary")
-                        
                         gr.Markdown("#### 📁 Exportación Personalizada")
                         with gr.Accordion("Selección de elementos para exportar", open=False):
                             export_options = gr.CheckboxGroup(
@@ -1933,36 +1811,28 @@ def create_gradio_interface():
                                 ],
                                 label="Elementos a incluir en la exportación"
                             )
-                        
                         export_custom_button = gr.Button("Exportar Selección Personalizada 📤", variant="secondary")
-                    
                     with gr.Column(scale=3):
                         gr.Markdown("#### 📄 Vista Previa del Reporte")
-                        
                         with gr.Tabs():
                             with gr.Tab("Vista General"):
                                 gr.Markdown("### Vista Previa del Reporte")
                                 report_preview = gr.Markdown("""
                                 # Informe de Optimización de Producción de AIA
-                                
                                 _Fecha: 15/05/2023_
-                                
                                 ## Resumen Ejecutivo
                                 Este informe presenta los resultados del análisis de superficie de respuesta 
                                 para la optimización del proceso de producción de AIA utilizando un diseño Box-Behnken.
-                                
                                 ## Hallazgos Clave
                                 - El modelo simplificado explica el 92.3% de la variabilidad observada
                                 - Los factores más influyentes fueron [X1] y [X2]
                                 - El punto óptimo identificado predice un valor de [Y] = 295.7 ppm
-                                
                                 ## Recomendaciones
                                 Se recomienda operar en los siguientes niveles:
                                 - [X1]: 3.5 g/L
                                 - [X2]: 0.2 g/L
                                 - [X3]: 0.65 g/L
                                 """)
-                            
                             with gr.Tab("Estructura del Reporte"):
                                 report_structure = gr.JSON(value={
                                     "Título": "Informe de Optimización de Producción de AIA",
@@ -1980,7 +1850,6 @@ def create_gradio_interface():
                                         "Gráficos de Superficie"
                                     ]
                                 })
-                
                 gr.Markdown("#### 📤 Historial de Exportaciones")
                 export_history = gr.Dataframe(
                     headers=["Fecha", "Tipo", "Elementos Exportados", "Tamaño"],
@@ -1990,7 +1859,6 @@ def create_gradio_interface():
                     ],
                     interactive=False
                 )
-        
         # Configuración de eventos
         load_button.click(
             load_data,
@@ -2003,18 +1871,16 @@ def create_gradio_interface():
             lambda: "Datos cargados correctamente. Puede avanzar a la pestaña de Análisis Estadístico.",
             outputs=status_output
         )
-        
         # Actualizar configuración de visualización
         update_vis_btn.click(
             update_visualization_settings,
-            inputs=[colorscale, opacity, show_grid, show_points, contour_levels],
+            inputs=[colorscale, opacity, show_grid, show_points, contour_levels, decimal_places_vis, pareto_statistic_vis],
             outputs=vis_status
         )
-        
         # Ajustar modelo y optimizar
         fit_button.click(
             fit_and_optimize_model,
-            inputs=[regularization_alpha, regularization_l1_ratio],
+            inputs=[regularization_alpha, regularization_l1_ratio, decimal_places, pareto_statistic],
             outputs=[
                 model_completo_output,
                 pareto_completo_output,
@@ -2043,7 +1909,6 @@ def create_gradio_interface():
                 download_excel_button
             ]
         )
-        
         # Generar y mostrar los gráficos
         plot_button.click(
             lambda fixed_var, fixed_lvl: (
@@ -2055,58 +1920,50 @@ def create_gradio_interface():
             inputs=[fixed_variable_input, fixed_level_input],
             outputs=[rsm_plot_output, plot_info, current_index_state, all_figures_state]
         )
-        
         # Generar contorno
         contour_button.click(
             generate_contour_plot,
             inputs=[fixed_variable_input, fixed_level_input, contour_levels],
             outputs=contour_plot_output
         )
-        
         # Navegación de gráficos
         left_button.click(
             lambda current_index, all_figures: navigate_plot('left', current_index, all_figures),
             inputs=[current_index_state, all_figures_state],
             outputs=[rsm_plot_output, plot_info, current_index_state]
         )
-        
         right_button.click(
             lambda current_index, all_figures: navigate_plot('right', current_index, all_figures),
             inputs=[current_index_state, all_figures_state],
             outputs=[rsm_plot_output, plot_info, current_index_state]
         )
-        
         # Descargar gráfico actual
         download_plot_button.click(
             download_current_plot,
             inputs=[all_figures_state, current_index_state],
             outputs=download_plot_button
         )
-        
         # Descargar todos los gráficos en ZIP
         download_all_plots_button.click(
             download_all_plots_zip,
             inputs=[],
             outputs=download_all_plots_button
         )
-        
         # Descargar todas las tablas en Excel y Word
         download_excel_button.click(
             fn=lambda: download_all_tables_excel(),
             inputs=[],
             outputs=download_excel_button
         )
-        
         download_word_button.click(
             fn=lambda: exportar_word(rsm, rsm.get_all_tables()),
             inputs=[],
             outputs=download_word_button
         )
-        
         # Optimización
         optimize_button.click(
             fit_and_optimize_model,
-            inputs=[regularization_alpha, regularization_l1_ratio],
+            inputs=[regularization_alpha, regularization_l1_ratio, decimal_places, pareto_statistic],
             outputs=[
                 model_completo_output,
                 pareto_completo_output,
@@ -2135,7 +1992,6 @@ def create_gradio_interface():
                 download_excel_button
             ]
         )
-        
         # Ejemplo de uso
         gr.Markdown("## 📌 Guía Rápida de Uso")
         gr.Markdown("""
@@ -2144,27 +2000,22 @@ def create_gradio_interface():
            - Especifique los niveles de cada factor
            - Cargue sus datos experimentales
            - Haga clic en "Cargar Datos"
-        
         2. **Análisis Estadístico**:
            - Ajuste los parámetros de regularización si es necesario
            - Haga clic en "Ejecutar Análisis Estadístico"
            - Revise los resultados de los modelos y diagnósticos
-        
         3. **Visualización**:
            - Personalice la apariencia de los gráficos
            - Seleccione qué variable mantener fija y en qué nivel
            - Genere y navegue entre los gráficos de superficie
-        
         4. **Optimización**:
            - Seleccione el método de optimización deseado
            - Haga clic en "Ejecutar Optimización"
            - Analice los resultados y recomendaciones
-        
         5. **Reporte y Exportación**:
            - Personalice y genere su reporte final
            - Exporte los resultados en el formato deseado
         """)
-    
     return demo
 
 # --- Función Principal ---