Update app.py

app.py

@@ -5,7 +5,7 @@ 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 t, f
+from scipy.stats import f
 import gradio as gr
 import io
 import zipfile
@@ -14,62 +14,92 @@ from datetime import datetime
 import docx
 from docx.shared import Inches, Pt
 from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
-from matplotlib.colors import to_hex
 import os
+from pyDOE import bbdesign, ccdesign
 
-# --- Clase RSM_BoxBehnken ---
-class RSM_BoxBehnken:
-    def __init__(self, data, x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels):
+# --- Clase RSM_ExperimentalDesign ---
+class RSM_ExperimentalDesign:
+    def __init__(self, data, design_type, factor_names, y_name, factor_levels):
         """
-        Inicializa la clase con los datos del diseño Box-Behnken.
+        Inicializa la clase con los datos del diseño experimental.
+        
+        Args:
+            data (pd.DataFrame): Datos del experimento.
+            design_type (str): Tipo de diseño ('Box-Behnken' o 'Central Compuesto').
+            factor_names (list): Lista de nombres de los factores.
+            y_name (str): Nombre de la variable dependiente.
+            factor_levels (dict): Diccionario con los niveles de cada factor.
         """
         self.data = data.copy()
+        self.design_type = design_type
+        self.factor_names = factor_names
+        self.y_name = y_name
+        self.factor_levels = factor_levels
         self.model = None
         self.model_simplified = None
         self.optimized_results = None
         self.optimal_levels = None
-        self.all_figures = []  # Lista para almacenar las figuras
-        self.x1_name = x1_name
-        self.x2_name = x2_name
-        self.x3_name = x3_name
-        self.y_name = y_name
-
-        # Niveles originales de las variables
-        self.x1_levels = x1_levels
-        self.x2_levels = x2_levels
-        self.x3_levels = x3_levels
+        self.all_figures = []
 
-    def get_levels(self, variable_name):
+    def generate_design(self):
         """
-        Obtiene los niveles para una variable específica.
+        Genera el diseño experimental basado en el tipo especificado y asigna los niveles naturales.
         """
-        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
+        num_factors = len(self.factor_names)
+        if self.design_type == 'Box-Behnken':
+            design = bbdesign(num_factors)
+        elif self.design_type == 'Central Compuesto':
+            design = ccdesign(num_factors, center=(3, 3))  # Puedes ajustar los puntos centrales si lo deseas
         else:
-            raise ValueError(f"Variable desconocida: {variable_name}")
+            raise ValueError("Tipo de diseño no soportado. Elige 'Box-Behnken' o 'Central Compuesto'.")
+        
+        # Asignar niveles naturales a las variables
+        for i, factor in enumerate(self.factor_names):
+            self.data[factor] = self.coded_to_natural(design[:, i], factor)
+        
+        return self.data
+
+    def coded_to_natural(self, coded_value, variable_name):
+        """Convierte un valor codificado a su valor natural."""
+        levels = self.factor_levels[variable_name]
+        if len(levels) != 3:
+            raise ValueError(f"Se requieren exactamente 3 niveles para el factor '{variable_name}'.")
+        return levels[0] + (coded_value + 1) * (levels[-1] - levels[0]) / 2
+
+    def natural_to_coded(self, natural_value, variable_name):
+        """Convierte un valor natural a su valor codificado."""
+        levels = self.factor_levels[variable_name]
+        return -1 + 2 * (natural_value - levels[0]) / (levels[-1] - levels[0])
 
     def fit_model(self):
         """
         Ajusta el modelo de segundo orden completo a los datos.
         """
-        formula = f'{self.y_name} ~ {self.x1_name} + {self.x2_name} + {self.x3_name} + ' \
-                  f'I({self.x1_name}**2) + I({self.x2_name}**2) + I({self.x3_name}**2) + ' \
-                  f'{self.x1_name}:{self.x2_name} + {self.x1_name}:{self.x3_name} + {self.x2_name}:{self.x3_name}'
+        terms = self.factor_names.copy()
+        # Términos cuadráticos
+        terms += [f'I({var}**2)' for var in self.factor_names]
+        # Términos de interacción
+        for i in range(len(self.factor_names)):
+            for j in range(i+1, len(self.factor_names)):
+                terms.append(f'{self.factor_names[i]}:{self.factor_names[j]}')
+        
+        formula = f'{self.y_name} ~ ' + ' + '.join(terms)
         self.model = smf.ols(formula, data=self.data).fit()
         print("Modelo Completo:")
         print(self.model.summary())
         return self.model, self.pareto_chart(self.model, "Pareto - Modelo Completo")
 
-    def fit_simplified_model(self):
+    def fit_simplified_model(self, selected_factors):
         """
-        Ajusta el modelo de segundo orden a los datos, eliminando términos no significativos.
+        Ajusta el modelo simplificado basado en los factores seleccionados.
+        
+        Args:
+            selected_factors (list): Lista de factores a incluir en el modelo.
         """
-        formula = f'{self.y_name} ~ {self.x1_name} + {self.x2_name} + ' \
-                  f'I({self.x1_name}**2) + I({self.x2_name}**2) + I({self.x3_name}**2)'
+        terms = selected_factors.copy()
+        # Términos cuadráticos
+        terms += [f'I({var}**2)' for var in selected_factors]
+        formula = f'{self.y_name} ~ ' + ' + '.join(terms)
         self.model_simplified = smf.ols(formula, data=self.data).fit()
         print("\nModelo Simplificado:")
         print(self.model_simplified.summary())
@@ -82,34 +112,32 @@ class RSM_BoxBehnken:
         if self.model_simplified is None:
             print("Error: Ajusta el modelo simplificado primero.")
             return
-
+        
         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]
-
-        bounds = [(-1, 1), (-1, 1), (-1, 1)]
-        x0 = [0, 0, 0]
-
+            input_data = {var: [x[i]] for i, var in enumerate(self.selected_factors)}
+            return -self.model_simplified.predict(pd.DataFrame(input_data)).values[0]
+        
+        # Definir límites codificados para cada factor
+        bounds = [(-1, 1) for _ in self.selected_factors]
+        x0 = [0] * len(self.selected_factors)
+        
         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)
+            self.coded_to_natural(self.optimal_levels[i], self.selected_factors[i])
+            for i in range(len(self.selected_factors))
         ]
+        
         # Crear la tabla de optimización
         optimization_table = pd.DataFrame({
-            'Variable': [self.x1_name, self.x2_name, self.x3_name],
+            'Variable': self.selected_factors,
             '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(3)
 
     def plot_rsm_individual(self, fixed_variable, fixed_level):
         """
@@ -119,12 +147,16 @@ class RSM_BoxBehnken:
             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]
+        varying_variables = [var for var in self.selected_factors if var != fixed_variable]
+        if len(varying_variables) < 2:
+            print("Se requieren al menos dos variables para generar un gráfico de superficie.")
+            return None
         
-        # 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])
+        var1, var2 = varying_variables[:2]  # Solo tomar las dos primeras variables para el gráfico
+        
+        # Determinar los niveles naturales para las variables que varían
+        x_natural_levels = self.factor_levels[var1]
+        y_natural_levels = self.factor_levels[var2]
 
         # 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)
@@ -132,39 +164,27 @@ class RSM_BoxBehnken:
         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])
+        x_grid_coded = self.natural_to_coded(x_grid_natural, var1)
+        y_grid_coded = self.natural_to_coded(y_grid_natural, var2)
 
         # Crear un DataFrame para la predicción con variables codificadas
         prediction_data = pd.DataFrame({
-            varying_variables[0]: x_grid_coded.flatten(),
-            varying_variables[1]: y_grid_coded.flatten(),
+            var1: x_grid_coded.flatten(),
+            var2: y_grid_coded.flatten(),
         })
-        prediction_data[fixed_variable] = self.natural_to_coded(fixed_level, fixed_variable)
+
+        # Asignar valores codificados a las otras variables fijas
+        for var in self.selected_factors:
+            if var not in [var1, var2]:
+                prediction_data[var] = self.natural_to_coded(fixed_level, var)
 
         # 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
+        # Crear el gráfico de superficie
         fig = go.Figure(data=[go.Surface(z=z_pred, x=x_grid_natural, y=y_grid_natural, colorscale='Viridis', opacity=0.7, showscale=True)])
 
-        # --- Añadir cuadrícula a la superficie ---
-        # Líneas en la dirección x
+        # Añadir líneas de cuadrícula
         for i in range(x_grid_natural.shape[0]):
             fig.add_trace(go.Scatter3d(
                 x=x_grid_natural[i, :],
@@ -175,7 +195,6 @@ class RSM_BoxBehnken:
                 showlegend=False,
                 hoverinfo='skip'
             ))
-        # Líneas en la dirección y
         for j in range(x_grid_natural.shape[1]):
             fig.add_trace(go.Scatter3d(
                 x=x_grid_natural[:, j],
@@ -187,18 +206,18 @@ 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
+        # Añadir los puntos de los experimentos
+        experiments_data = self.data.copy()
+        experiments_data['Predicho'] = self.model_simplified.predict(self.data[self.selected_factors])
         colors = px.colors.qualitative.Safe
         point_labels = [f"{row[self.y_name]:.3f}" 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),
+            x=experiments_data[var1],
+            y=experiments_data[var2],
+            z=experiments_data[self.y_name],
             mode='markers+text',
-            marker=dict(size=4, color=colors[:len(experiments_x_natural)]),
+            marker=dict(size=4, color=colors[:len(experiments_data)]),
             text=point_labels,
             textposition='top center',
             name='Experimentos'
@@ -207,11 +226,11 @@ class RSM_BoxBehnken:
         # Añadir etiquetas y título con variables naturales
         fig.update_layout(
             scene=dict(
-                xaxis_title=f"{varying_variables[0]} ({self.get_units(varying_variables[0])})",
-                yaxis_title=f"{varying_variables[1]} ({self.get_units(varying_variables[1])})",
+                xaxis_title=f"{var1} ({self.get_units(var1)})",
+                yaxis_title=f"{var2} ({self.get_units(var2)})",
                 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 {var1} y {var2}<br><sup>{fixed_variable} fijo en {fixed_level:.3f} ({self.get_units(fixed_variable)}) (Modelo Simplificado)</sup>",
             height=800,
             width=1000,
             showlegend=True
@@ -226,8 +245,9 @@ class RSM_BoxBehnken:
         units = {
             'Glucosa': 'g/L',
             'Extracto_de_Levadura': 'g/L',
-            'Triptofano': 'g/L',
-            'AIA_ppm': 'ppm'
+            'Triptófano': 'g/L',
+            'AIA_ppm': 'ppm',
+            # Agrega más unidades según tus variables
         }
         return units.get(variable_name, '')
 
@@ -243,36 +263,21 @@ class RSM_BoxBehnken:
         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
-        }
+        levels_to_plot_natural = self.factor_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]:
+        for fixed_variable in self.selected_factors:
+            for level in self.factor_levels[fixed_variable]:
                 fig = self.plot_rsm_individual(fixed_variable, level)
                 if fig is not None:
                     self.all_figures.append(fig)
 
-    def coded_to_natural(self, coded_value, variable_name):
-        """Convierte un valor codificado a su valor natural."""
-        levels = self.get_levels(variable_name)
-        return levels[0] + (coded_value + 1) * (levels[-1] - levels[0]) / 2
-
-    def natural_to_coded(self, natural_value, variable_name):
-        """Convierte un valor natural a su valor codificado."""
-        levels = self.get_levels(variable_name)
-        return -1 + 2 * (natural_value - levels[0]) / (levels[-1] - levels[0])
-
     def pareto_chart(self, model, title):
         """
         Genera un diagrama de Pareto para los efectos usando estadísticos F,
         incluyendo la línea de significancia.
         """
         # Calcular los estadísticos F para cada término
-        # F = (coef/std_err)^2 = t^2
         fvalues = model.tvalues[1:]**2  # Excluir la Intercept y convertir t a F
         abs_fvalues = np.abs(fvalues)
         sorted_idx = np.argsort(abs_fvalues)[::-1]
@@ -315,21 +320,15 @@ class RSM_BoxBehnken:
 
         for term, coef in coefficients.items():
             if term != 'Intercept':
-                if term == f'{self.x1_name}':
-                    equation += f" + {coef:.3f}*{self.x1_name}"
-                elif term == f'{self.x2_name}':
-                    equation += f" + {coef:.3f}*{self.x2_name}"
-                elif term == f'{self.x3_name}':
-                    equation += f" + {coef:.3f}*{self.x3_name}"
-                elif term == f'I({self.x1_name} ** 2)':
-                    equation += f" + {coef:.3f}*{self.x1_name}^2"
-                elif term == f'I({self.x2_name} ** 2)':
-                    equation += f" + {coef:.3f}*{self.x2_name}^2"
-                elif term == f'I({self.x3_name} ** 2)':
-                    equation += f" + {coef:.3f}*{self.x3_name}^2"
-
+                if term.startswith('I('):
+                    equation += f" + {coef:.3f}*{term[2:-1]}"
+                elif ':' in term:
+                    equation += f" + {coef:.3f}*{term}"
+                else:
+                    equation += f" + {coef:.3f}*{term}"
+        
         return equation
-    
+
     def generate_prediction_table(self):
         """
         Genera una tabla con los valores actuales, predichos y residuales.
@@ -338,7 +337,7 @@ class RSM_BoxBehnken:
             print("Error: Ajusta el modelo simplificado primero.")
             return None
 
-        self.data['Predicho'] = self.model_simplified.predict(self.data)
+        self.data['Predicho'] = self.model_simplified.predict(self.data[self.selected_factors])
         self.data['Residual'] = self.data[self.y_name] - self.data['Predicho']
 
         return self.data[[self.y_name, 'Predicho', 'Residual']].round(3)
@@ -370,54 +369,13 @@ class RSM_BoxBehnken:
     
         # 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
-        block_ms = block_ss / block_df
-        block_f = block_ms / ms_error
-        block_p = f.sf(block_f, block_df, anova_table.loc['Residual', 'df'])
-        block_contribution = (block_ss / ss_total) * 100
     
-        contribution_table = pd.concat([contribution_table, pd.DataFrame({
-            'Fuente de Variación': ['Block'],
-            'Suma de Cuadrados': [block_ss],
-            'Grados de Libertad': [block_df],
-            'Cuadrado Medio': [block_ms],
-            'F': [block_f],
-            '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()
-        model_ms = model_ss / model_df
-        model_f = model_ms / ms_error
-        model_p = f.sf(model_f, model_df, anova_table.loc['Residual', 'df'])
-        model_contribution = (model_ss / ss_total) * 100
-    
-        contribution_table = pd.concat([contribution_table, pd.DataFrame({
-            'Fuente de Variación': ['Model'],
-            'Suma de Cuadrados': [model_ss],
-            'Grados de Libertad': [model_df],
-            'Cuadrado Medio': [model_ms],
-            'F': [model_f],
-            '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':
                 factor_name = index
-                if factor_name == f'I({self.x1_name} ** 2)':
-                    factor_name = f'{self.x1_name}^2'
-                elif factor_name == f'I({self.x2_name} ** 2)':
-                    factor_name = f'{self.x2_name}^2'
-                elif factor_name == f'I({self.x3_name} ** 2)':
-                    factor_name = f'{self.x3_name}^2'
-    
+                if factor_name.startswith('I('):
+                    factor_name = factor_name[2:-1]  # Quitar 'I(' y ')'
                 ss_factor = row['sum_sq']
                 df_factor = row['df']
                 ms_factor = ss_factor / df_factor
@@ -436,13 +394,10 @@ class RSM_BoxBehnken:
                 })], ignore_index=True)
     
         # Agregar fila para Cor Total
-        cor_total_ss = ss_total
-        cor_total_df = len(self.data) - 1
-    
         contribution_table = pd.concat([contribution_table, pd.DataFrame({
             'Fuente de Variación': ['Cor Total'],
-            'Suma de Cuadrados': [cor_total_ss],
-            'Grados de Libertad': [cor_total_df],
+            'Suma de Cuadrados': [ss_total],
+            'Grados de Libertad': [len(self.data) - 1],
             'Cuadrado Medio': [np.nan],
             'F': [np.nan],
             'Valor p': [np.nan],
@@ -459,88 +414,60 @@ class RSM_BoxBehnken:
             print("Error: Ajusta el modelo simplificado primero.")
             return None
 
-        # --- ANOVA detallada ---
-        # 1. Ajustar un modelo solo con los términos de primer orden y cuadráticos
-        formula_reduced = f'{self.y_name} ~ {self.x1_name} + {self.x2_name} + {self.x3_name} + ' \
-                         f'I({self.x1_name}**2) + I({self.x2_name}**2) + I({self.x3_name}**2)'
-        model_reduced = smf.ols(formula_reduced, data=self.data).fit()
-
-        # 2. ANOVA del modelo reducido
-        anova_reduced = sm.stats.anova_lm(model_reduced, typ=2)
+        # ANOVA del modelo simplificado
+        anova_reduced = sm.stats.anova_lm(self.model_simplified, typ=2)
 
-        # 3. Suma de cuadrados total
+        # 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'
+        # Suma de cuadrados de la regresión
+        ss_regression = anova_reduced['sum_sq'].sum()
 
-        # 6. Grados de libertad de la regresión
-        df_regression = len(anova_reduced) - 1
+        # Grados de libertad de la regresión
+        df_regression = anova_reduced['df'].sum()
 
-        # 7. Suma de cuadrados del error residual
-        ss_residual = self.model_simplified.ssr
-        df_residual = self.model_simplified.df_resid
+        # Suma de cuadrados del error residual
+        ss_residual = anova_reduced.loc['Residual', 'sum_sq']
+        df_residual = anova_reduced.loc['Residual', 'df']
 
-        # 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:
-            ss_pure_error = replicas.groupby([self.x1_name, self.x2_name, self.x3_name])[self.y_name].var().sum() * replicas.groupby([self.x1_name, self.x2_name, self.x3_name]).ngroups
-            df_pure_error = len(replicas) - replicas.groupby([self.x1_name, self.x2_name, self.x3_name]).ngroups
+        # Suma de cuadrados del error puro (si hay réplicas)
+        duplicates = self.data.duplicated(subset=self.selected_factors, keep=False)
+        if duplicates.any():
+            ss_pure_error = self.data[duplicates].groupby(self.selected_factors)[self.y_name].var().sum() * self.data[duplicates].groupby(self.selected_factors).ngroups()
+            df_pure_error = self.data[duplicates].shape[0] - self.data[duplicates].groupby(self.selected_factors).ngroups()
         else:
             ss_pure_error = np.nan
             df_pure_error = np.nan
 
-        # 9. Suma de cuadrados de la falta de ajuste
+        # 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
+        # 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
+        # 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
+        # Crear la tabla ANOVA detallada
         detailed_anova_table = pd.DataFrame({
             'Fuente de Variación': ['Regresión', 'Residual', 'Falta de Ajuste', 'Error Puro', 'Total'],
             'Suma de Cuadrados': [ss_regression, ss_residual, ss_lack_of_fit, ss_pure_error, ss_total],
-            'Grados de Libertad': [df_regression, df_residual, df_lack_of_fit, df_pure_error, df_total],
+            'Grados de Libertad': [df_regression, df_residual, df_lack_of_fit, df_pure_error, len(self.data) - 1],
             'Cuadrado Medio': [ms_regression, ms_residual, ms_lack_of_fit, ms_pure_error, np.nan],
             'F': [f_regression, np.nan, f_lack_of_fit, np.nan, np.nan],
             'Valor p': [p_regression, np.nan, p_lack_of_fit, np.nan, np.nan]
         })
-        
-        # Calcular la suma de cuadrados y estadísticos F para la curvatura
-        ss_curvature = anova_reduced['sum_sq'][f'I({self.x1_name} ** 2)'] + \
-                      anova_reduced['sum_sq'][f'I({self.x2_name} ** 2)'] + \
-                      anova_reduced['sum_sq'][f'I({self.x3_name} ** 2)']
-        df_curvature = 3
-        ms_curvature = ss_curvature / df_curvature
-        f_curvature = ms_curvature / ms_residual
-        p_curvature = 1 - f.cdf(f_curvature, df_curvature, df_residual)
-
-        # Añadir la fila de curvatura a la tabla ANOVA
-        detailed_anova_table.loc[len(detailed_anova_table)] = [
-            'Curvatura', 
-            ss_curvature, 
-            df_curvature, 
-            ms_curvature,
-            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)
+        detailed_anova_table = detailed_anova_table.reindex([0, 1, 2, 3, 4]).reset_index(drop=True)
 
         return detailed_anova_table.round(3)
 
@@ -550,12 +477,12 @@ class RSM_BoxBehnken:
         """
         prediction_table = self.generate_prediction_table()
         contribution_table = self.calculate_contribution_percentage()
-        detailed_anova_table = self.calculate_detailed_anova()
+        anova_table = self.calculate_detailed_anova()
 
         return {
             'Predicciones': prediction_table,
             '% Contribución': contribution_table,
-            'ANOVA Detallada': detailed_anova_table
+            'ANOVA Detallada': anova_table
         }
 
     def save_figures_to_zip(self):
@@ -674,58 +601,80 @@ class RSM_BoxBehnken:
 
 # --- Funciones para la Interfaz de Gradio ---
 
-def load_data(x1_name, x2_name, x3_name, y_name, x1_levels_str, x2_levels_str, x3_levels_str, data_str):
+def load_data(design_type, factor_names, factor_levels, y_name, data_str):
     """
-    Carga los datos del diseño Box-Behnken desde cajas de texto y crea la instancia de RSM_BoxBehnken.
+    Carga los datos del diseño experimental desde las entradas y crea la instancia de RSM_ExperimentalDesign.
     """
     try:
-        # Convertir los niveles a listas de números
-        x1_levels = [float(x.strip()) for x in x1_levels_str.split(',')]
-        x2_levels = [float(x.strip()) for x in x2_levels_str.split(',')]
-        x3_levels = [float(x.strip()) for x in x3_levels_str.split(',')]
+        # Parsear nombres de factores
+        factor_names = [fn.strip() for fn in factor_names.split(',')]
+        num_factors = len(factor_names)
+
+        # Parsear niveles de factores
+        factor_levels_dict = {}
+        levels = factor_levels.split(';')
+        if len(levels) != num_factors:
+            raise ValueError(f"Se esperaban {num_factors} conjuntos de niveles separados por ';'.")
+        for i, level_str in enumerate(levels):
+            level_values = [float(x.strip()) for x in level_str.split(',')]
+            if len(level_values) != 3:
+                raise ValueError(f"El factor '{factor_names[i]}' requiere exactamente 3 niveles separados por comas.")
+            factor_levels_dict[factor_names[i]] = level_values
 
         # Crear DataFrame a partir de la cadena de datos
         data_list = [row.split(',') for row in data_str.strip().split('\n')]
-        column_names = ['Exp.', x1_name, x2_name, x3_name, y_name]
+        column_names = ['Exp.'] + factor_names + [y_name]
         data = pd.DataFrame(data_list, columns=column_names)
         data = data.apply(pd.to_numeric, errors='coerce')  # Convertir a numérico
 
-        # Validar que el DataFrame tenga las columnas correctas
-        if not all(col in data.columns for col in column_names):
-            raise ValueError("El formato de los datos no es correcto.")
-
-        # Crear la instancia de RSM_BoxBehnken
+        # Crear la instancia de RSM_ExperimentalDesign
         global rsm
-        rsm = RSM_BoxBehnken(data, x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels)
+        rsm = RSM_ExperimentalDesign(
+            data=data,
+            design_type=design_type,
+            factor_names=factor_names,
+            y_name=y_name,
+            factor_levels=factor_levels_dict
+        )
+
+        # Generar el diseño
+        rsm.generate_design()
+
+        return data.round(3), gr.update(visible=True), factor_names
 
-        return data.round(3), x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels, gr.update(visible=True)
-    
     except Exception as e:
         # Mostrar mensaje de error
         error_message = f"Error al cargar los datos: {str(e)}"
         print(error_message)
-        return None, "", "", "", "", [], [], [], gr.update(visible=False)
+        return None, gr.update(visible=False), []
 
-def fit_and_optimize_model():
+def fit_and_optimize_model(selected_factors):
     if 'rsm' not in globals():
         return [None]*11  # Ajustar el número de outputs
 
+    if not selected_factors:
+        return [None]*11  # No se han seleccionado factores
+
     # Ajustar modelos y optimizar
     model_completo, pareto_completo = rsm.fit_model()
-    model_simplificado, pareto_simplificado = rsm.fit_simplified_model()
+    rsm.selected_factors = selected_factors
+    model_simplificado, pareto_simplificado = rsm.fit_simplified_model(selected_factors)
     optimization_table = rsm.optimize()
     equation = rsm.get_simplified_equation()
     prediction_table = rsm.generate_prediction_table()
     contribution_table = rsm.calculate_contribution_percentage()
     anova_table = rsm.calculate_detailed_anova()
-    
+
     # Generar todas las figuras y almacenarlas
     rsm.generate_all_plots()
-    
+
     # 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}"
-    
+    if equation:
+        equation_formatted = equation.replace(" + ", "<br>+ ").replace(" ** ", "^").replace("*", " × ")
+        equation_formatted = f"### Ecuación del Modelo Simplificado:<br>{equation_formatted}"
+    else:
+        equation_formatted = "No se pudo generar la ecuación del modelo simplificado."
+
     # Guardar las tablas en Excel temporal
     excel_path = rsm.save_tables_to_excel()
 
@@ -746,32 +695,6 @@ def fit_and_optimize_model():
         excel_path   # Ruta del Excel de tablas
     )
 
-def show_plot(current_index, all_figures):
-    if not all_figures:
-        return None, "No hay gráficos disponibles.", current_index
-    selected_fig = all_figures[current_index]
-    plot_info_text = f"Gráfico {current_index + 1} de {len(all_figures)}"
-    return selected_fig, plot_info_text, current_index
-
-def navigate_plot(direction, current_index, all_figures):
-    """
-    Navega entre los gráficos.
-    """
-    if not all_figures:
-        return None, "No hay gráficos disponibles.", current_index
-    
-    if direction == 'left':
-        new_index = (current_index - 1) % len(all_figures)
-    elif direction == 'right':
-        new_index = (current_index + 1) % len(all_figures)
-    else:
-        new_index = current_index
-    
-    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_current_plot(all_figures, current_index):
     """
     Descarga la figura actual como PNG.
@@ -781,12 +704,12 @@ def download_current_plot(all_figures, current_index):
     fig = all_figures[current_index]
     img_bytes = rsm.save_fig_to_bytes(fig)
     filename = f"Grafico_RSM_{current_index + 1}.png"
-    
+
     # Crear un archivo temporal
     with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as temp_file:
         temp_file.write(img_bytes)
         temp_path = temp_file.name
-    
+
     return temp_path  # Retornar solo la ruta
 
 def download_all_plots_zip():
@@ -797,8 +720,6 @@ def download_all_plots_zip():
         return None
     zip_path = rsm.save_figures_to_zip()
     if zip_path:
-        filename = f"Graficos_RSM_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
-        # Gradio no permite renombrar directamente, por lo que retornamos la ruta del archivo
         return zip_path
     return None
 
@@ -810,16 +731,16 @@ def download_all_tables_excel():
         return None
     excel_path = rsm.save_tables_to_excel()
     if excel_path:
-        filename = f"Tablas_RSM_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
-        # Gradio no permite renombrar directamente, por lo que retornamos la ruta del archivo
         return excel_path
     return None
 
-def exportar_word(rsm_instance, tables_dict):
+def exportar_word(tables_dict):
     """
     Función para exportar las tablas a un documento de Word.
     """
-    word_path = rsm_instance.export_tables_to_word(tables_dict)
+    if 'rsm' not in globals():
+        return None
+    word_path = rsm.export_tables_to_word(tables_dict)
     if word_path and os.path.exists(word_path):
         return word_path
     return None
@@ -828,19 +749,32 @@ def exportar_word(rsm_instance, tables_dict):
 
 def create_gradio_interface():
     with gr.Blocks() as demo:
-        gr.Markdown("# Optimización de la producción de AIA usando RSM Box-Behnken")
-        
+        gr.Markdown("# Optimización de la Producción de AIA usando RSM")
+
         with gr.Row():
             with gr.Column():
                 gr.Markdown("## Configuración del Diseño")
-                x1_name_input = gr.Textbox(label="Nombre de la Variable X1 (ej. Glucosa)", value="Glucosa")
-                x2_name_input = gr.Textbox(label="Nombre de la Variable X2 (ej. Extracto de Levadura)", value="Extracto_de_Levadura")
-                x3_name_input = gr.Textbox(label="Nombre de la Variable X3 (ej. Triptófano)", value="Triptofano")
-                y_name_input = gr.Textbox(label="Nombre de la Variable Dependiente (ej. AIA (ppm))", value="AIA_ppm")
-                x1_levels_input = gr.Textbox(label="Niveles de X1 (separados por comas)", value="1, 3.5, 5.5")
-                x2_levels_input = gr.Textbox(label="Niveles de X2 (separados por comas)", value="0.03, 0.2, 0.3")
-                x3_levels_input = gr.Textbox(label="Niveles de X3 (separados por comas)", value="0.4, 0.65, 0.9")
-                data_input = gr.Textbox(label="Datos del Experimento (formato CSV)", lines=10, value="""1,-1,-1,0,166.594
+                design_type_input = gr.Dropdown(
+                    label="Tipo de Diseño",
+                    choices=["Box-Behnken", "Central Compuesto"],
+                    value="Box-Behnken"
+                )
+                factor_names_input = gr.Textbox(
+                    label="Nombres de los Factores (separados por comas)",
+                    value="Glucosa, Extracto_de_Levadura, Triptófano"
+                )
+                factor_levels_input = gr.Textbox(
+                    label="Niveles de los Factores (cada conjunto separado por ';' y niveles separados por comas)",
+                    value="1, 3.5, 5.5; 0.03, 0.2, 0.3; 0.4, 0.65, 0.9"
+                )
+                y_name_input = gr.Textbox(
+                    label="Nombre de la Variable Dependiente (ej. AIA_ppm)",
+                    value="AIA_ppm"
+                )
+                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
 3,-1,1,0,127.261
 4,1,1,0,147.573
@@ -854,13 +788,14 @@ def create_gradio_interface():
 12,0,1,1,148.621
 13,0,0,0,278.951
 14,0,0,0,297.238
-15,0,0,0,280.896""")
+15,0,0,0,280.896"""
+                )
                 load_button = gr.Button("Cargar Datos")
-            
+
             with gr.Column():
                 gr.Markdown("## Datos Cargados")
                 data_output = gr.Dataframe(label="Tabla de Datos", interactive=False)
-        
+
         # Sección de análisis visible solo después de cargar los datos
         with gr.Row(visible=False) as analysis_row:
             with gr.Column():
@@ -873,41 +808,52 @@ def create_gradio_interface():
                 pareto_simplificado_output = gr.Plot()
                 gr.Markdown("**Ecuación del Modelo Simplificado**")
                 equation_output = gr.HTML()
+                gr.Markdown("**Tabla de Optimización**")
                 optimization_table_output = gr.Dataframe(label="Tabla de Optimización", interactive=False)
+                gr.Markdown("**Tabla de Predicciones**")
                 prediction_table_output = gr.Dataframe(label="Tabla de Predicciones", interactive=False)
+                gr.Markdown("**Tabla de % de Contribución**")
                 contribution_table_output = gr.Dataframe(label="Tabla de % de Contribución", interactive=False)
+                gr.Markdown("**Tabla ANOVA Detallada**")
                 anova_table_output = gr.Dataframe(label="Tabla ANOVA Detallada", interactive=False)
                 gr.Markdown("## Descargar Todas las Tablas")
-                download_excel_button = gr.DownloadButton("Descargar Tablas en Excel")
-                download_word_button = gr.DownloadButton("Descargar Tablas en Word")
-            
+                download_excel_button = gr.File(label="Descargar Tablas en Excel", visible=False)
+                download_word_button = gr.File(label="Descargar Tablas en Word", visible=False)
+
             with gr.Column():
+                gr.Markdown("## Selección de Factores para el Modelo Simplificado")
+                selected_factors_input = gr.CheckboxGroup(
+                    label="Selecciona los Factores a Incluir",
+                    choices=[],  # Actualizar dinámicamente
+                    value=[]
+                )
+                fit_button_2 = gr.Button("Aplicar Selección de Factores")
+                gr.Markdown("## Resultados de Optimización")
+                optimization_table_output_2 = gr.Dataframe(label="Tabla de Optimización", interactive=False)
                 gr.Markdown("## Generar Gráficos de Superficie de Respuesta")
-                fixed_variable_input = gr.Dropdown(label="Variable Fija", choices=["Glucosa", "Extracto_de_Levadura", "Triptofano"], value="Glucosa")
-                fixed_level_input = gr.Slider(label="Nivel de Variable Fija", minimum=-1, maximum=1, step=0.01, value=0.0)
                 plot_button = gr.Button("Generar Gráficos")
                 with gr.Row():
                     left_button = gr.Button("<")
                     right_button = gr.Button(">")
                 rsm_plot_output = gr.Plot()
-                plot_info = gr.Textbox(label="Información del Gráfico", value="Gráfico 1 de 9", interactive=False)
+                plot_info = gr.Textbox(label="Información del Gráfico", value="Gráfico 1 de 0", 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)")
+                    download_plot_button = gr.File(label="Descargar Gráfico Actual (PNG)", visible=False)
+                    download_all_plots_button = gr.File(label="Descargar Todos los Gráficos (ZIP)", visible=False)
                 current_index_state = gr.State(0)  # Estado para el índice actual
                 all_figures_state = gr.State([])  # Estado para todas las figuras
-    
-        # Cargar datos
+
+        # Funciones de carga y ajuste
         load_button.click(
             load_data,
-            inputs=[x1_name_input, x2_name_input, x3_name_input, y_name_input, x1_levels_input, x2_levels_input, x3_levels_input, data_input],
-            outputs=[data_output, x1_name_input, x2_name_input, x3_name_input, y_name_input, x1_levels_input, x2_levels_input, x3_levels_input, analysis_row]
+            inputs=[design_type_input, factor_names_input, factor_levels_input, y_name_input, data_input],
+            outputs=[data_output, analysis_row, selected_factors_input]
         )
-        
+
         # Ajustar modelo y optimizar
         fit_button.click(
             fit_and_optimize_model,
-            inputs=[],
+            inputs=[selected_factors_input],
             outputs=[
                 model_completo_output,
                 pareto_completo_output,
@@ -918,23 +864,36 @@ def create_gradio_interface():
                 prediction_table_output,
                 contribution_table_output,
                 anova_table_output,
-                download_all_plots_button,  # Ruta del ZIP de gráficos
-                download_excel_button      # Ruta del Excel de tablas
+                download_all_plots_button,
+                download_excel_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.get_all_tables()),
+            inputs=[],
+            outputs=download_word_button
+        )
+
         # Generar y mostrar los gráficos
         plot_button.click(
-            lambda fixed_var, fixed_lvl: (
-                rsm.plot_rsm_individual(fixed_var, fixed_lvl),
-                f"Gráfico 1 de {len(rsm.all_figures)}" if rsm.all_figures else "No hay gráficos disponibles.",
+            lambda: (
+                None,  # Placeholder, se actualizará después
+                "No hay gráficos disponibles.",
                 0,
-                rsm.all_figures  # Actualizar el estado de todas las figuras
+                []
             ),
-            inputs=[fixed_variable_input, fixed_level_input],
+            inputs=[],
             outputs=[rsm_plot_output, plot_info, current_index_state, all_figures_state]
         )
-        
+
         # Navegación de gráficos
         left_button.click(
             lambda current_index, all_figures: navigate_plot('left', current_index, all_figures),
@@ -946,50 +905,116 @@ def create_gradio_interface():
             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
-        )
-        
+
         # Ejemplo de uso
         gr.Markdown("## Ejemplo de uso")
         gr.Markdown("""
-        1. Introduce los nombres de las variables y sus niveles en las cajas de texto correspondientes.
-        2. Copia y pega los datos del experimento en la caja de texto 'Datos del Experimento'.
-        3. Haz clic en 'Cargar Datos' para cargar los datos en la tabla.
-        4. Haz clic en 'Ajustar Modelo y Optimizar' para ajustar el modelo y encontrar los niveles óptimos de los factores.
-        5. Selecciona una variable fija y su nivel en los controles deslizantes.
-        6. Haz clic en 'Generar Gráficos' para generar los gráficos de superficie de respuesta.
-        7. Navega entre los gráficos usando los botones '<' y '>'.
-        8. Descarga el gráfico actual en PNG o descarga todos los gráficos en un ZIP.
-        9. Descarga todas las tablas en un archivo Excel o Word con los botones correspondientes.
+        1. **Configura el Diseño:**
+            - Selecciona el tipo de diseño (Box-Behnken o Central Compuesto).
+            - Ingresa los nombres de los factores separados por comas.
+            - Ingresa los niveles de cada factor separados por comas y cada conjunto de niveles por ';'.
+            - Especifica el nombre de la variable dependiente.
+            - Proporciona los datos del experimento en formato CSV.
+        2. **Cargar Datos:**
+            - Haz clic en 'Cargar Datos' para cargar y visualizar los datos.
+        3. **Ajustar Modelo y Optimizar:**
+            - Selecciona los factores que deseas incluir en el modelo simplificado.
+            - Haz clic en 'Ajustar Modelo y Optimizar' para ajustar los modelos y obtener los resultados.
+        4. **Generar Gráficos:**
+            - Haz clic en 'Generar Gráficos' para crear las superficies de respuesta.
+            - Navega entre los gráficos usando los botones '<' y '>'.
+            - Descarga el gráfico actual en PNG o descarga todos los gráficos en un ZIP.
+        5. **Descargar Tablas:**
+            - Descarga todas las tablas generadas en un archivo Excel o Word.
         """)
 
     return demo
 
+def navigate_plot(direction, current_index, all_figures):
+    """
+    Navega entre los gráficos.
+    """
+    if not all_figures:
+        return None, "No hay gráficos disponibles.", current_index
+
+    if direction == 'left':
+        new_index = (current_index - 1) % len(all_figures)
+    elif direction == 'right':
+        new_index = (current_index + 1) % len(all_figures)
+    else:
+        new_index = current_index
+
+    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
+
+# --- Funciones de descarga y exportación ---
+
+def download_current_plot(all_figures, current_index):
+    """
+    Descarga la figura actual como PNG.
+    """
+    if not all_figures:
+        return None
+    fig = all_figures[current_index]
+    img_bytes = rsm.save_fig_to_bytes(fig)
+    filename = f"Grafico_RSM_{current_index + 1}.png"
+
+    # Crear un archivo temporal
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as temp_file:
+        temp_file.write(img_bytes)
+        temp_path = temp_file.name
+
+    return temp_path  # Retornar solo la ruta
+
+def download_all_plots_zip():
+    """
+    Descarga todas las figuras en un archivo ZIP.
+    """
+    if 'rsm' not in globals():
+        return None
+    zip_path = rsm.save_figures_to_zip()
+    if zip_path:
+        return zip_path
+    return None
+
+def download_all_tables_excel():
+    """
+    Descarga todas las tablas en un archivo Excel con múltiples hojas.
+    """
+    if 'rsm' not in globals():
+        return None
+    excel_path = rsm.save_tables_to_excel()
+    if excel_path:
+        return excel_path
+    return None
+
+def exportar_word(tables_dict):
+    """
+    Función para exportar las tablas a un documento de Word.
+    """
+    if not tables_dict:
+        return None
+    word_path = rsm.export_tables_to_word(tables_dict)
+    if word_path and os.path.exists(word_path):
+        return word_path
+    return None
+
 # --- Función Principal ---
 
 def main():
@@ -997,4 +1022,4 @@ def main():
     interface.launch(share=True)
 
 if __name__ == "__main__":
-    main()
+    main()