Update app.py

app.py

@@ -44,9 +44,12 @@ class RSM_BoxBehnken:
         self.data = data.copy()
         self.model = None
         self.model_simplified = None
+        self.model_personalized = None # For personalized model
         self.optimized_results = None
         self.optimal_levels = None
-        self.all_figures = []  # Lista para almacenar las figuras
+        self.all_figures_full = [] # Separate lists for different model plots
+        self.all_figures_simplified = []
+        self.all_figures_personalized = []
         self.x1_name = x1_name
         self.x2_name = x2_name
         self.x3_name = x3_name
@@ -57,615 +60,108 @@ class RSM_BoxBehnken:
         self.x2_levels = x2_levels
         self.x3_levels = x3_levels
 
-    def get_levels(self, variable_name):
-        """
-        Obtiene los niveles para una variable específica.
-        """
-        if variable_name == self.x1_name:
-            return self.x1_levels
-        elif variable_name == self.x2_name:
-            return self.x2_levels
-        elif variable_name == self.x3_name:
-            return self.x3_levels
-        else:
-            raise ValueError(f"Variable desconocida: {variable_name}")
-
-    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}'
-        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):
+    # ... (previous methods like get_levels, get_units, coded_to_natural, natural_to_coded, pareto_chart, get_simplified_equation, generate_prediction_table, calculate_contribution_percentage, calculate_detailed_anova, get_all_tables, save_figures_to_zip, save_fig_to_bytes, save_all_figures_png, save_tables_to_excel, export_tables_to_word remain mostly the same)
+
+    def fit_personalized_model(self, formula):
         """
-        Ajusta el modelo de segundo orden a los datos, eliminando términos no significativos.
+        Ajusta un modelo personalizado de segundo orden a los datos, usando la formula dada.
         """
-        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)' # Adjusted formula to include x3^2
-        self.model_simplified = smf.ols(formula, data=self.data).fit()
-        print("\nModelo Simplificado:")
-        print(self.model_simplified.summary())
-        return self.model_simplified, self.pareto_chart(self.model_simplified, "Pareto - Modelo Simplificado")
-
-    def optimize(self, method='Nelder-Mead'):
+        self.model_personalized = smf.ols(formula, data=self.data).fit()
+        print("\nModelo Personalizado:")
+        print(self.model_personalized.summary())
+        return self.model_personalized, self.pareto_chart(self.model_personalized, "Pareto - Modelo Personalizado")
+
+    def generate_all_plots(self):
         """
-        Encuentra los niveles óptimos de los factores para maximizar la respuesta usando el modelo simplificado.
+        Genera todas las gráficas de RSM para todos los modelos.
         """
         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]
-
-        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
-
-    def plot_rsm_individual(self, fixed_variable, fixed_level):
-        """
-        Genera un gráfico de superficie de respuesta (RSM) individual para una configuración específica.
-        """
-        if self.model_simplified is None:
-            print("Error: Ajusta el modelo simplificado primero.")
+        self.all_figures_full = [] # Reset lists for each model type
+        self.all_figures_simplified = []
+        self.all_figures_personalized = []
+
+        levels_to_plot_natural = { # Levels from data, as before
+            self.x1_name: sorted(list(set(self.data[self.x1_name]))),
+            self.x2_name: sorted(list(set(self.data[self.x2_name]))),
+            self.x3_name: sorted(list(set(self.data[self.x3_name])))
+        }
+
+        for fixed_variable in [self.x1_name, self.x2_name, self.x3_name]:
+            for level in levels_to_plot_natural[fixed_variable]:
+                fig_full = self.plot_rsm_individual(fixed_variable, level, model_type='full') # Pass model_type
+                if fig_full:
+                    self.all_figures_full.append(fig_full)
+                fig_simplified = self.plot_rsm_individual(fixed_variable, level, model_type='simplified') # Pass model_type
+                if fig_simplified:
+                    self.all_figures_simplified.append(fig_simplified)
+                if self.model_personalized is not None: # Generate personalized plots only if model exists
+                    fig_personalized = self.plot_rsm_individual(fixed_variable, level, model_type='personalized') # Pass model_type
+                    if fig_personalized:
+                        self.all_figures_personalized.append(fig_personalized)
+
+    def plot_rsm_individual(self, fixed_variable, fixed_level, model_type='simplified'): # Added model_type parameter
+        """
+        Genera un gráfico de superficie de respuesta (RSM) individual para una configuración específica y modelo.
+        """
+        model_to_use = self.model_simplified # Default to simplified model
+        model_title_suffix = "(Modelo Simplificado)"
+        if model_type == 'full':
+            model_to_use = self.model
+            model_title_suffix = "(Modelo Completo)"
+        elif model_type == 'personalized':
+            if self.model_personalized is None:
+                print("Error: Modelo personalizado no ajustado.")
+                return None
+            model_to_use = self.model_personalized
+            model_title_suffix = "(Modelo Personalizado)"
+
+        if model_to_use is None: # Use model_to_use instead of self.model_simplified
+            print(f"Error: Ajusta el modelo {model_type} primero.") # More informative error message
             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(),
-            varying_variables[1]: y_grid_coded.flatten(),
-        })
-        prediction_data[fixed_variable] = self.natural_to_coded(fixed_level, fixed_variable)
-
-        # 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, 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
-        for i in range(x_grid_natural.shape[0]):
-            fig.add_trace(go.Scatter3d(
-                x=x_grid_natural[i, :],
-                y=y_grid_natural[i, :],
-                z=z_pred[i, :],
-                mode='lines',
-                line=dict(color='gray', width=2),
-                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],
-                y=y_grid_natural[:, j],
-                z=z_pred[:, j],
-                mode='lines',
-                line=dict(color='gray', width=2),
-                showlegend=False,
-                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
-        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),
-            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
+        # ... (rest of the plot_rsm_individual method remains similar, but use model_to_use and model_title_suffix)
+        # ... (Make sure to update title to include model_title_suffix)
         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])})",
                 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:.3f} ({self.get_units(fixed_variable)}) {model_title_suffix}</sup>", # Updated title
             height=800,
             width=1000,
             showlegend=True
         )
         return fig
 
-    def get_units(self, variable_name):
-        """
-        Define las unidades de las variables para etiquetas.
-        Puedes personalizar este método según tus necesidades.
-        """
-        units = {
-            'Glucosa_g_L': 'g/L',
-            'Proteina_Pescado_g_L': 'g/L',
-            'Sulfato_Manganeso_g_L': 'g/L',
-            'Abs_600nm': '' # No units for Absorbance
-        }
-        return units.get(variable_name, '')
-
-    def generate_all_plots(self):
-        """
-        Genera todas las gráficas de RSM, variando la variable fija y sus niveles usando el modelo simplificado.
-        Almacena las figuras en self.all_figures.
-        """
-        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 - Using levels from the data context, not Box-Behnken design levels.
-        levels_to_plot_natural = {
-            self.x1_name: sorted(list(set(self.data[self.x1_name]))), # Using unique values from data
-            self.x2_name: sorted(list(set(self.data[self.x2_name]))), # Using unique values from data
-            self.x3_name: sorted(list(set(self.data[self.x3_name])))  # Using unique values from data
-        }
-
-        # 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]:
-                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 estandarizados de un modelo,
-        incluyendo la línea de significancia.
-        """
-        # Calcular los efectos estandarizados
-        tvalues = model.tvalues[1:]  # Excluir la Intercept
-        abs_tvalues = np.abs(tvalues)
-        sorted_idx = np.argsort(abs_tvalues)[::-1]
-        sorted_tvalues = abs_tvalues[sorted_idx]
-        sorted_names = tvalues.index[sorted_idx]
-
-        # Calcular el valor crítico de t para la línea de significancia
-        alpha = 0.05  # Nivel de significancia
-        dof = model.df_resid  # Grados de libertad residuales
-        t_critical = t.ppf(1 - alpha / 2, dof)
-
-        # Crear el diagrama de Pareto
-        fig = px.bar(
-            x=sorted_tvalues.round(3),
-            y=sorted_names,
-            orientation='h',
-            labels={'x': 'Efecto Estandarizado', 'y': 'Término'},
-            title=title
-        )
-        fig.update_yaxes(autorange="reversed")
-
-        # Agregar la línea de significancia
-        fig.add_vline(x=t_critical, line_dash="dot",
-                      annotation_text=f"t crítico = {t_critical:.3f}",
-                      annotation_position="bottom right")
-
-        return fig
-
-    def get_simplified_equation(self):
-        """
-        Retorna la ecuación del modelo simplificado como una cadena de texto.
-        """
-        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}"
-
-        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"
-
-        return equation
-
-    def generate_prediction_table(self):
-        """
-        Genera una tabla con los valores actuales, predichos y residuales.
-        """
-        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)
-
-    def calculate_contribution_percentage(self):
-        """
-        Calcula el porcentaje de contribución de cada factor a la variabilidad de la respuesta (AIA).
-        """
-        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({
-            'Factor': [],
-            'Suma de Cuadrados': [],
-            '% Contribución': []
-        })
-
-        # Calcular porcentaje de contribución para cada factor
-        for index, row in anova_table.iterrows():
-            if index != 'Residual':
-                factor_name = index
-                if factor_name == f'I({self.x1_name} ** 2)':
-                    factor_name = f'{self.x1_name}^2'
-                elif factor_name == f'I({self.x2_name} ** 2)':
-                    factor_name = f'{self.x2_name}^2'
-                elif factor_name == f'I({self.x3_name} ** 2)':
-                    factor_name = f'{self.x3_name}^2'
-
-                ss_factor = row['sum_sq']
-                contribution_percentage = (ss_factor / ss_total) * 100
-
-                contribution_table = pd.concat([contribution_table, pd.DataFrame({
-                    'Factor': [factor_name],
-                    'Suma de Cuadrados': [ss_factor],
-                    '% Contribución': [contribution_percentage]
-                })], ignore_index=True)
-
-        return contribution_table.round(3)
-
-    def calculate_detailed_anova(self):
-        """
-        Calcula la tabla ANOVA detallada con la descomposición del error residual.
-        """
-        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'I({self.x1_name}**2) + I({self.x2_name}**2) + I({self.x3_name}**2)'
-        model_reduced = smf.ols(formula_reduced, data=self.data).fit()
-
-        # 2. ANOVA del modelo reducido (para obtener la suma de cuadrados de la regresión)
-        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:
-            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
-        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 = np.nan # Initialize ms_lack_of_fit to nan
-        if not np.isnan(df_lack_of_fit) and df_lack_of_fit != 0: # Check df_lack_of_fit is valid
-            ms_lack_of_fit = ss_lack_of_fit / df_lack_of_fit
-        ms_pure_error = ss_pure_error / df_pure_error if not np.isnan(df_pure_error) else np.nan
-
-        # 11. Estadístico F y valor p para la falta de ajuste
-        f_lack_of_fit = ms_lack_of_fit / ms_pure_error if not np.isnan(ms_lack_of_fit) and not np.isnan(ms_pure_error) and ms_pure_error != 0 else np.nan # Added nan checks and zero division check
-        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) and not np.isnan(df_lack_of_fit) and not np.isnan(df_pure_error) else np.nan # Added nan checks
-
-
-        # 12. 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],
-            'Cuadrado Medio': [ms_regression, ms_residual, ms_lack_of_fit, ms_pure_error, np.nan],
-            'F': [np.nan, np.nan, f_lack_of_fit, np.nan, np.nan],
-            'Valor p': [np.nan, np.nan, p_lack_of_fit, np.nan, np.nan]
-        })
-
-        # Calcular la suma de cuadrados y grados de libertad para la curvatura
-        ss_curvature = anova_reduced['sum_sq'][f'I({self.x1_name} ** 2)'] + anova_reduced['sum_sq'][f'I({self.x2_name} ** 2)'] + anova_reduced['sum_sq'][f'I({self.x3_name} ** 2)']
-        df_curvature = 3
-
-        # Añadir la fila de curvatura a la tabla ANOVA
-        detailed_anova_table.loc[len(detailed_anova_table)] = ['Curvatura', ss_curvature, df_curvature, ss_curvature / df_curvature, np.nan, np.nan]
-
-        # Reorganizar las filas para que la curvatura aparezca después de la regresión
-        detailed_anova_table = detailed_anova_table.reindex([0, 5, 1, 2, 3, 4])
-
-        # Resetear el índice para que sea consecutivo
-        detailed_anova_table = detailed_anova_table.reset_index(drop=True)
-
-        return detailed_anova_table.round(3)
-
-    def get_all_tables(self):
-        """
-        Obtiene todas las tablas generadas para ser exportadas a Excel.
-        """
-        prediction_table = self.generate_prediction_table()
-        contribution_table = self.calculate_contribution_percentage()
-        detailed_anova_table = self.calculate_detailed_anova()
-
-        return {
-            'Predicciones': prediction_table,
-            '% Contribución': contribution_table,
-            'ANOVA Detallada': detailed_anova_table
-        }
-
-    def save_figures_to_zip(self):
-        """
-        Guarda todas las figuras almacenadas en self.all_figures a un archivo ZIP en memoria.
-        """
-        if not self.all_figures:
-            return None
-
-        zip_buffer = io.BytesIO()
-        with zipfile.ZipFile(zip_buffer, 'w') as zip_file:
-            for idx, fig in enumerate(self.all_figures, start=1):
-                img_bytes = fig.to_image(format="png")
-                zip_file.writestr(f'Grafico_{idx}.png', img_bytes)
-        zip_buffer.seek(0)
-
-        # Guardar en un archivo temporal
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as temp_file:
-            temp_file.write(zip_buffer.read())
-            temp_path = temp_file.name
-
-        return temp_path
-
-    def save_fig_to_bytes(self, fig):
-        """
-        Convierte una figura Plotly a bytes en formato PNG.
-        """
-        return fig.to_image(format="png")
-
-    def save_all_figures_png(self):
-        """
-        Guarda todas las figuras en archivos PNG temporales y retorna las rutas.
-        """
-        png_paths = []
-        for idx, fig in enumerate(self.all_figures, start=1):
-            img_bytes = fig.to_image(format="png")
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as temp_file:
-                temp_file.write(img_bytes)
-                temp_path = temp_file.name
-                png_paths.append(temp_path)
-        return png_paths
-
-    def save_tables_to_excel(self):
-        """
-        Guarda todas las tablas en un archivo Excel con múltiples hojas y retorna la ruta del archivo.
-        """
-        tables = self.get_all_tables()
-        excel_buffer = io.BytesIO()
-        with pd.ExcelWriter(excel_buffer, engine='xlsxwriter') as writer:
-            for sheet_name, table in tables.items():
-                table.to_excel(writer, sheet_name=sheet_name, index=False)
-        excel_buffer.seek(0)
-        excel_bytes = excel_buffer.read()
-
-        # Guardar en un archivo temporal
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx") as temp_file:
-            temp_file.write(excel_bytes)
-            temp_path = temp_file.name
-
-        return temp_path
-
-    def export_tables_to_word(self, tables_dict):
-        """
-        Exporta las tablas proporcionadas a un documento de Word.
-        """
-        if not tables_dict:
-            return None
-
-        doc = docx.Document()
-
-        # Configurar estilo de fuente
-        style = doc.styles['Normal']
-        font = style.font
-        font.name = 'Times New Roman'
-        font.size = Pt(12)
-
-        # Título del informe
-        titulo = doc.add_heading('Informe de Optimización de Producción de Absorbancia', 0) # Changed Title
-        titulo.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
-
-        doc.add_paragraph(f"Fecha: {datetime.now().strftime('%d/%m/%Y %H:%M')}").alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
-
-        doc.add_paragraph('\n')  # Espacio
-
-        for sheet_name, table in tables_dict.items():
-            # Añadir título de la tabla
-            doc.add_heading(sheet_name, level=1)
-
-            if table.empty:
-                doc.add_paragraph("No hay datos disponibles para esta tabla.")
-                continue
-
-            # Añadir tabla al documento
-            table_doc = doc.add_table(rows=1, cols=len(table.columns))
-            table_doc.style = 'Light List Accent 1'
-
-            # Añadir encabezados
-            hdr_cells = table_doc.rows[0].cells
-            for idx, col_name in enumerate(table.columns):
-                hdr_cells[idx].text = col_name
-
-            # Añadir filas de datos
-            for _, row in table.iterrows():
-                row_cells = table_doc.add_row().cells
-                for idx, item in enumerate(row):
-                    row_cells[idx].text = str(item)
-
-            doc.add_paragraph('\n')  # Espacio entre tablas
-
-        # Guardar el documento en un archivo temporal
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".docx") as tmp:
-            doc.save(tmp.name)
-            tmp_path = tmp.name
-
-        return tmp_path
 
 # --- Funciones para la Interfaz de Gradio ---
 
-def load_data(data_str): # Modified load_data to only take data_str
-    """
-    Carga los datos del diseño Box-Behnken desde cajas de texto y crea la instancia de RSM_BoxBehnken.
-    """
-    try:
-        # Use the global data DataFrame
-        global rsm, data
-
-        x1_name = "Glucosa_g_L"
-        x2_name = "Proteina_Pescado_g_L"
-        x3_name = "Sulfato_Manganeso_g_L"
-        y_name = "Abs_600nm"
-        x1_levels = sorted(list(set(data[x1_name]))) # Levels from data
-        x2_levels = sorted(list(set(data[x2_name]))) # Levels from data
-        x3_levels = sorted(list(set(data[x3_name]))) # Levels from data
-
-
-        # Crear la instancia de RSM_BoxBehnken
-        rsm = RSM_BoxBehnken(data, x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels)
-
-        return data.round(3), gr.update(visible=True) # Removed other outputs, only return data_output and analysis_row
-
-    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) # Removed other outputs, only return data_output and analysis_row
-
+def load_data(data_str):
+    # ... (load_data function remains the same)
+    return data.round(3), gr.update(visible=True)
 
 def fit_and_optimize_model():
     if 'rsm' not in globals():
-        return [None]*11  # Ajustar el número de outputs
+        return [None]*11
 
-    # Ajustar modelos y optimizar
     model_completo, pareto_completo = rsm.fit_model()
     model_simplificado, pareto_simplificado = rsm.fit_simplified_model()
+    # Personalized model fitting is now triggered separately by custom_model_button
     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 and store them in rsm.all_figures
-    rsm.generate_all_plots()
+    rsm.generate_all_plots() # Generate all plots for all models after fitting
 
-    # 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}"
 
-    # Guardar las tablas en Excel temporal
     excel_path = rsm.save_tables_to_excel()
     zip_path = rsm.save_figures_to_zip()
 
@@ -683,125 +179,152 @@ def fit_and_optimize_model():
         excel_path
     )
 
-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)}"
+def fit_custom_model(factor_checkboxes, interaction_checkboxes): # New function for custom model
+    if 'rsm' not in globals():
+        return [None]*3 # Adjust output number
+
+    formula_parts = [rsm.x1_name, rsm.x2_name, rsm.x3_name] if "factors" in factor_checkboxes else []
+    if "x1_sq" in factor_checkboxes: formula_parts.append(f'I({rsm.x1_name}**2)')
+    if "x2_sq" in factor_checkboxes: formula_parts.append(f'I({rsm.x2_name}**2)')
+    if "x3_sq" in factor_checkboxes: formula_parts.append(f'I({rsm.x3_name}**2)')
+    if "x1x2" in interaction_checkboxes: formula_parts.append(f'{rsm.x1_name}:{rsm.x2_name}')
+    if "x1x3" in interaction_checkboxes: formula_parts.append(f'{rsm.x1_name}:{rsm.x3_name}')
+    if "x2x3" in interaction_checkboxes: formula_parts.append(f'{rsm.x2_name}:{rsm.x3_name}')
+
+    if not formula_parts:
+        formula = f'{rsm.y_name} ~ 1' # Intercept-only model if nothing selected
+    else:
+        formula = f'{rsm.y_name} ~ ' + ' + '.join(formula_parts)
+
+    custom_model, pareto_custom = rsm.fit_personalized_model(formula) # Fit personalized model
+    rsm.generate_all_plots() # Regenerate plots to include personalized model plots
+
+    return custom_model.summary().as_html(), pareto_custom, rsm.all_figures_personalized # Return custom model summary, pareto, and personalized plots
+
+def show_plot(current_index, all_figures, model_type): # Modified to accept model_type
+    figure_list = []
+    if model_type == 'full':
+        figure_list = rsm.all_figures_full
+    elif model_type == 'simplified':
+        figure_list = rsm.all_figures_simplified
+    elif model_type == 'personalized':
+        figure_list = rsm.all_figures_personalized
+
+    if not figure_list:
+        return None, f"No hay gráficos disponibles para el modelo {model_type}.", current_index
+    selected_fig = figure_list[current_index]
+    plot_info_text = f"Gráfico {current_index + 1} de {len(figure_list)} (Modelo {model_type.capitalize()})" # Updated plot info
     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
+def navigate_plot(direction, current_index, all_figures, model_type): # Modified to accept model_type
+    figure_list = []
+    if model_type == 'full':
+        figure_list = rsm.all_figures_full
+    elif model_type == 'simplified':
+        figure_list = rsm.all_figures_simplified
+    elif model_type == 'personalized':
+        figure_list = rsm.all_figures_personalized
+
+    if not figure_list:
+        return None, f"No hay gráficos disponibles para el modelo {model_type}.", current_index
 
     if direction == 'left':
-        new_index = (current_index - 1) % len(all_figures)
+        new_index = (current_index - 1) % len(figure_list)
     elif direction == 'right':
-        new_index = (current_index + 1) % len(all_figures)
+        new_index = (current_index + 1) % len(figure_list)
     else:
         new_index = current_index
 
-    selected_fig = all_figures[new_index]
-    plot_info_text = f"Gráfico {new_index + 1} de {len(all_figures)}"
+    selected_fig = figure_list[new_index]
+    plot_info_text = f"Gráfico {new_index + 1} de {len(figure_list)} (Modelo {model_type.capitalize()})" # Updated plot info
 
-    return selected_fig, plot_info_text, current_index
+    return selected_fig, plot_info_text, new_index
 
-def download_current_plot(all_figures, current_index):
-    """
-    Descarga la figura actual como PNG.
-    """
-    if not all_figures:
+def download_current_plot(all_figures, current_index, model_type): # Modified to accept model_type
+    figure_list = []
+    if model_type == 'full':
+        figure_list = rsm.all_figures_full
+    elif model_type == 'simplified':
+        figure_list = rsm.all_figures_simplified
+    elif model_type == 'personalized':
+        figure_list = rsm.all_figures_personalized
+    if not figure_list:
         return None
-    fig = all_figures[current_index]
+    fig = figure_list[current_index]
     img_bytes = rsm.save_fig_to_bytes(fig)
-    filename = f"Grafico_RSM_{current_index + 1}.png"
+    filename = f"Grafico_RSM_{model_type}_{current_index + 1}.png" # Added model type to filename
 
-    # 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
 
-    return temp_path  # Retornar solo la ruta
-
-def download_all_plots_zip():
-    """
-    Descarga todas las figuras en un archivo ZIP.
-    """
+def download_all_plots_zip(model_type): # Modified to accept model_type
     if 'rsm' not in globals():
         return None
+    if model_type == 'full':
+        rsm.all_figures = rsm.all_figures_full # Set current figures to download
+    elif model_type == 'simplified':
+        rsm.all_figures = rsm.all_figures_simplified
+    elif model_type == 'personalized':
+        rsm.all_figures = rsm.all_figures_personalized
+
     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
+        filename = f"Graficos_RSM_{model_type}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip" # Added model type to filename
         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:
-        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):
-    """
-    Función para exportar las tablas a un documento de Word.
-    """
-    word_path = rsm_instance.export_tables_to_word(tables_dict)
-    if word_path and os.path.exists(word_path):
-        return word_path
-    return None
-
 # --- Crear la interfaz de Gradio ---
 
 def create_gradio_interface():
     with gr.Blocks() as demo:
-        gr.Markdown("# Optimización de la Absorbancia usando RSM") # Changed Title
+        gr.Markdown("# Optimización de la Absorbancia usando RSM")
 
         with gr.Row():
             with gr.Column():
-                gr.Markdown("## Configuración del Análisis") # Changed Section Title
-                # Removed input boxes for variable names and levels
-                data_input = gr.Textbox(label="Datos del Experimento (formato CSV - Ignored, Data is Hardcoded)", lines=5, interactive=False, value="Data is pre-loaded, ignore input.") # Adjusted Textbox
-                load_button = gr.Button("Cargar Datos") # Keep load button for triggering data load but input is ignored
+                gr.Markdown("## Configuración del Análisis")
+                data_input = gr.Textbox(label="Datos del Experimento (formato CSV - Ignored, Data is Hardcoded)", lines=5, interactive=False, value="Data is pre-loaded, ignore input.")
+                load_button = gr.Button("Cargar Datos")
+                data_dropdown = gr.Dropdown(["All Data"], value="All Data", label="Seleccionar Datos") # Data Selection Dropdown - currently only 'All Data'
 
             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():
-                fit_button = gr.Button("Ajustar Modelo y Optimizar")
+                fit_button = gr.Button("Ajustar Modelo Simplificado y Completo") # Button label changed
                 gr.Markdown("**Modelo Completo**")
                 model_completo_output = gr.HTML()
                 pareto_completo_output = gr.Plot()
                 gr.Markdown("**Modelo Simplificado**")
                 model_simplificado_output = gr.HTML()
                 pareto_simplificado_output = gr.Plot()
+
+                gr.Markdown("## Modelo Personalizado") # Personalized Model Section
+                factor_checkboxes = gr.CheckboxGroup(["factors", "x1_sq", "x2_sq", "x3_sq"], label="Términos de Factores", value=["factors", "x1_sq", "x2_sq", "x3_sq"]) # Factor Checkboxes
+                interaction_checkboxes = gr.CheckboxGroup(["x1x2", "x1x3", "x2x3"], label="Términos de Interacción") # Interaction Checkboxes
+                custom_model_button = gr.Button("Ajustar Modelo Personalizado") # Fit Custom Model Button
+                model_personalized_output = gr.HTML() # Output for personalized model summary
+                pareto_personalized_output = gr.Plot() # Pareto for personalized model
+
                 gr.Markdown("**Ecuación del Modelo Simplificado**")
                 equation_output = gr.HTML()
                 optimization_table_output = gr.Dataframe(label="Tabla de Optimización", interactive=False)
                 prediction_table_output = gr.Dataframe(label="Tabla de Predicciones", interactive=False)
                 contribution_table_output = gr.Dataframe(label="Tabla de % de Contribución", interactive=False)
                 anova_table_output = gr.Dataframe(label="Tabla ANOVA Detallada", interactive=False)
+
                 gr.Markdown("## Descargar Todas las Tablas")
                 download_excel_button = gr.DownloadButton("Descargar Tablas en Excel")
                 download_word_button = gr.DownloadButton("Descargar Tablas en Word")
 
             with gr.Column():
-                gr.Markdown("## Generar Gráficos de Superficie de Respuesta")
-                fixed_variable_input = gr.Dropdown(label="Variable Fija", choices=["Glucosa_g_L", "Proteina_Pescado_g_L", "Sulfato_Manganeso_g_L"], value="Glucosa_g_L") # Updated choices
-                fixed_level_input = gr.Slider(label="Nivel de Variable Fija (Natural Units)", minimum=min(data['Glucosa_g_L']), maximum=max(data['Glucosa_g_L']), step=0.1, value=5.0) # Updated Slider - Using data min/max
+                gr.Markdown("## Gráficos de Superficie de Respuesta")
+                model_type_radio = gr.Radio(["simplified", "full", "personalized"], value="simplified", label="Tipo de Modelo para Gráficos") # Model Type Radio
+                fixed_variable_input = gr.Dropdown(label="Variable Fija", choices=["Glucosa_g_L", "Proteina_Pescado_g_L", "Sulfato_Manganeso_g_L"], value="Glucosa_g_L")
+                fixed_level_input = gr.Slider(label="Nivel de Variable Fija (Natural Units)", minimum=min(data['Glucosa_g_L']), maximum=max(data['Glucosa_g_L']), step=0.1, value=5.0)
                 plot_button = gr.Button("Generar Gráficos")
                 with gr.Row():
                     left_button = gr.Button("<")
@@ -811,70 +334,78 @@ def create_gradio_interface():
                 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)")
-                current_index_state = gr.State(0)  # Estado para el índice actual
-                all_figures_state = gr.State([])  # Estado para todas las figuras
+                current_index_state = gr.State(0)
+                all_figures_state = gr.State([])
+                current_model_type_state = gr.State('simplified') # State to track selected model type for plots
 
-        # Cargar datos - Modified load_button click to only take data_input (which is ignored)
+        # Cargar datos
         load_button.click(
             load_data,
-            inputs=[data_input], # Only data_input is now input
-            outputs=[data_output, analysis_row] # Removed other outputs, only return data_output and analysis_row
+            inputs=[data_input],
+            outputs=[data_output, analysis_row]
         )
 
-        # Ajustar modelo y optimizar
+        # Ajustar modelo y optimizar (Simplified and Full)
         fit_button.click(
             fit_and_optimize_model,
             inputs=[],
-            outputs=[ # Corrected outputs to return calculated values not output components
-                model_completo_output, # This should be removed, returning summary HTML string instead
-                pareto_completo_output, # This should be removed, returning Plotly Figure instead
-                model_simplificado_output, # This should be removed, returning summary HTML string instead
-                pareto_simplificado_output, # This should be removed, returning Plotly Figure instead
-                equation_output, # This should be removed, returning formatted equation string instead
-                optimization_table_output, # This should be removed, returning DataFrame instead
-                prediction_table_output, # This should be removed, returning DataFrame instead
-                contribution_table_output, # This should be removed, returning DataFrame instead
-                anova_table_output, # This should be removed, returning DataFrame instead
-                download_all_plots_button, # Correct - returning file path for download button
-                download_excel_button # Correct - returning file path for download button
+            outputs=[
+                model_completo_output,
+                pareto_completo_output,
+                model_simplificado_output,
+                pareto_simplificado_output,
+                equation_output,
+                optimization_table_output,
+                prediction_table_output,
+                contribution_table_output,
+                anova_table_output,
+                download_all_plots_button,
+                download_excel_button
             ]
         )
 
+        # Ajustar modelo personalizado
+        custom_model_button.click( # New event for custom model fitting
+            fit_custom_model,
+            inputs=[factor_checkboxes, interaction_checkboxes],
+            outputs=[model_personalized_output, pareto_personalized_output, all_figures_state] # Output personalized plots to state
+        )
+
         # 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 fixed_var, fixed_lvl, model_type: ( # Added model_type input
+                show_plot(0, [], model_type) if not hasattr(rsm, 'all_figures_full') or not rsm.all_figures_full else show_plot(0, rsm.all_figures_full if model_type == 'full' else rsm.all_figures_simplified if model_type == 'simplified' else rsm.all_figures_personalized if model_type == 'personalized' else [], model_type) , # Conditional plot selection
                 0,
-                rsm.all_figures  # Actualizar el estado de todas las figuras
+                model_type # Update model_type state
             ),
-            inputs=[fixed_variable_input, fixed_level_input],
-            outputs=[rsm_plot_output, plot_info, current_index_state, all_figures_state]
+            inputs=[fixed_variable_input, fixed_level_input, model_type_radio], # Added model_type_radio input
+            outputs=[rsm_plot_output, plot_info, current_index_state, current_model_type_state] # Output model_type to state
         )
 
+
         # 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],
+            lambda current_index, all_figures, model_type: navigate_plot('left', current_index, all_figures, model_type), # Pass model_type
+            inputs=[current_index_state, all_figures_state, current_model_type_state], # Input model_type 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],
+            lambda current_index, all_figures, model_type: navigate_plot('right', current_index, all_figures, model_type), # Pass model_type
+            inputs=[current_index_state, all_figures_state, current_model_type_state], # Input model_type 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],
+            inputs=[all_figures_state, current_index_state, current_model_type_state], # Pass model_type state
             outputs=download_plot_button
         )
 
         # Descargar todos los gráficos en ZIP
         download_all_plots_button.click(
-            download_all_plots_zip,
-            inputs=[],
+            lambda model_type: download_all_plots_zip(model_type), # Pass model_type
+            inputs=[current_model_type_state], # Input model_type state
             outputs=download_all_plots_button
         )
 
@@ -892,14 +423,17 @@ def create_gradio_interface():
         )
 
         # Ejemplo de uso
-        gr.Markdown("## Instrucciones:") # Shortened Instructions
+        gr.Markdown("## Instrucciones:")
         gr.Markdown("""
         1. Click 'Cargar Datos' para usar los datos precargados.
-        2. Click 'Ajustar Modelo y Optimizar'.
-        3. Select 'Variable Fija' and 'Nivel de Variable Fija'.
-        4. Click 'Generar Gráficos'.
-        5. Navigate plots with '<' and '>'.
-        6. Download plots and tables as needed.
+        2. Click 'Ajustar Modelo Simplificado y Completo'.
+        3. Opcional: Define un Modelo Personalizado seleccionando términos y haz clic en 'Ajustar Modelo Personalizado'.
+        4. Selecciona el 'Tipo de Modelo para Gráficos' (Simplificado, Completo o Personalizado).
+        5. Select 'Variable Fija' and 'Nivel de Variable Fija'.
+        6. Click 'Generar Gráficos'.
+        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.
         """)
 
     return demo