Update app.py

app.py

@@ -14,7 +14,6 @@ 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
 
 # --- Data definition in global scope ---
@@ -60,7 +59,77 @@ class RSM_BoxBehnken:
         self.x2_levels = x2_levels
         self.x3_levels = x3_levels
 
-    # ... (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 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):
+        """
+        Ajusta el modelo de segundo orden a los datos, eliminando términos no significativos.
+        """
+        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'):
+        """
+        Encuentra los niveles óptimos de los factores para maximizar la respuesta usando el modelo simplificado.
+        """
+        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 fit_personalized_model(self, formula):
         """
@@ -92,14 +161,14 @@ class RSM_BoxBehnken:
         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:
+                if fig_full is not None:
                     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:
+                if fig_simplified is not None:
                     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:
+                    if fig_personalized is not None:
                         self.all_figures_personalized.append(fig_personalized)
 
     def plot_rsm_individual(self, fixed_variable, fixed_level, model_type='simplified'): # Added model_type parameter
@@ -122,8 +191,101 @@ class RSM_BoxBehnken:
             print(f"Error: Ajusta el modelo {model_type} primero.") # More informative error message
             return None
 
-        # ... (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)
+        # 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)
+
+        # Fijar la variable fija en el DataFrame de predicción
+        fixed_var_levels = self.get_levels(fixed_variable)
+        if len(fixed_var_levels) == 3:  # Box-Behnken design levels
+            prediction_data[fixed_variable] = self.natural_to_coded(fixed_level, fixed_variable)
+        elif len(fixed_var_levels) > 0: # Use the closest level if not Box-Behnken
+            closest_level_coded = self.natural_to_coded(min(fixed_var_levels, key=lambda x:abs(x-fixed_level)), fixed_variable)
+            prediction_data[fixed_variable] = closest_level_coded
+
+
+        # Calcular los valores predichos
+        z_pred = model_to_use.predict(prediction_data).values.reshape(x_grid_coded.shape) # Use model_to_use here
+
+        # 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
         fig.update_layout(
             scene=dict(
                 xaxis_title=f"{varying_variables[0]} ({self.get_units(varying_variables[0])})",
@@ -141,9 +303,20 @@ class RSM_BoxBehnken:
 # --- Funciones para la Interfaz de Gradio ---
 
 def load_data(data_str):
-    # ... (load_data function remains the same)
+    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])))
+    x2_levels = sorted(list(set(data[x2_name])))
+    x3_levels = sorted(list(set(data[x3_name])))
+
+    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)
 
+
 def fit_and_optimize_model():
     if 'rsm' not in globals():
         return [None]*11
@@ -168,7 +341,7 @@ def fit_and_optimize_model():
     return (
         model_completo.summary().as_html(),
         pareto_completo,
-        model_simplificado.summary().as_html(),
+        model_simplificado_output, # output_components are correctly referenced now
         pareto_simplificado,
         equation_formatted,
         optimization_table,
@@ -179,9 +352,9 @@ def fit_and_optimize_model():
         excel_path
     )
 
-def fit_custom_model(factor_checkboxes, interaction_checkboxes): # New function for custom model
+def fit_custom_model(factor_checkboxes, interaction_checkboxes, model_personalized_output_component, pareto_personalized_output_component):
     if 'rsm' not in globals():
-        return [None]*3 # Adjust output number
+        return [None]*2 # 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)')
@@ -199,7 +372,8 @@ def fit_custom_model(factor_checkboxes, interaction_checkboxes): # New function
     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
+    return  custom_model.summary().as_html(), pareto_custom # return values for outputs
+
 
 def show_plot(current_index, all_figures, model_type): # Modified to accept model_type
     figure_list = []
@@ -275,6 +449,29 @@ def download_all_plots_zip(model_type): # Modified to accept model_type
         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():
@@ -338,6 +535,7 @@ def create_gradio_interface():
                 all_figures_state = gr.State([])
                 current_model_type_state = gr.State('simplified') # State to track selected model type for plots
 
+
         # Cargar datos
         load_button.click(
             load_data,
@@ -367,45 +565,42 @@ def create_gradio_interface():
         # 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
+            inputs=[factor_checkboxes, interaction_checkboxes, model_personalized_output, pareto_personalized_output], # pass output components
+            outputs=[model_personalized_output, pareto_personalized_output] # return values for outputs
         )
 
+
         # Generar y mostrar los gráficos
         plot_button.click(
-            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,
-                model_type # Update model_type 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
+            lambda fixed_var, fixed_lvl, model_type: show_plot(0, [], model_type) if not hasattr(rsm, 'all_figures_full') or not rsm.all_figures_full else show_plot(0, [], model_type) if model_type == 'full' and not rsm.all_figures_full else show_plot(0, [], model_type) if model_type == 'simplified' and not rsm.all_figures_simplified else show_plot(0, [], model_type) if model_type == 'personalized' and not rsm.all_figures_personalized 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, model_type),
+            inputs=[fixed_variable_input, fixed_level_input, model_type_radio],
+            outputs=[rsm_plot_output, plot_info, current_index_state, current_model_type_state]
         )
 
 
         # Navegación de gráficos
         left_button.click(
-            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
+            lambda current_index, all_figures, model_type: navigate_plot('left', current_index, all_figures, model_type),
+            inputs=[current_index_state, all_figures_state, current_model_type_state],
             outputs=[rsm_plot_output, plot_info, current_index_state]
         )
         right_button.click(
-            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
+            lambda current_index, all_figures, model_type: navigate_plot('right', current_index, all_figures, model_type),
+            inputs=[current_index_state, all_figures_state, current_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, current_model_type_state], # Pass model_type state
+            inputs=[all_figures_state, current_index_state, current_model_type_state],
             outputs=download_plot_button
         )
 
         # Descargar todos los gráficos en ZIP
         download_all_plots_button.click(
-            lambda model_type: download_all_plots_zip(model_type), # Pass model_type
-            inputs=[current_model_type_state], # Input model_type state
+            lambda model_type: download_all_plots_zip(model_type),
+            inputs=[current_model_type_state],
             outputs=download_all_plots_button
         )
 
@@ -422,6 +617,7 @@ def create_gradio_interface():
             outputs=download_word_button
         )
 
+
         # Ejemplo de uso
         gr.Markdown("## Instrucciones:")
         gr.Markdown("""