Update app.py

app.py

@@ -80,23 +80,42 @@ class GraphTheoryAnalysis:
     def set_matrices_and_values(self):
         self.all_factors = list(self.experiment.factor_values.keys())
 
-    def build_graph(self, level=3):
-        if level > len(self.all_factors):
-            level = len(self.all_factors)  # Ajustar el nivel al número de factores disponibles
-
-        for combo in combinations(self.all_factors, level):
-            if len(combo) >= 2:  # Asegurarse de que hay suficientes elementos para formar pares
-                # Crear todos los pares posibles dentro de la combinación
-                for pair in combinations(combo, 2):
-                    self.experiment.set_active_factors(list(pair))
-                    self.experiment.fit_models()
-                    r2 = (self.experiment.r2_variable1 + self.experiment.r2_variable2) / 2
-                    if self.graph.has_edge(pair[0], pair[1]):
-                        # Si la arista ya existe, tomar el valor máximo de R²
-                        existing_r2 = self.graph[pair[0]][pair[1]]['weight']
-                        self.graph[pair[0]][pair[1]]['weight'] = max(existing_r2, r2)
-                    else:
-                        self.graph.add_edge(pair[0], pair[1], weight=r2)
+    def build_graph(self, level=2, r2_threshold=0.5):
+        """
+        Construye el grafo basado en el nivel de combinación.
+        
+        Args:
+            level (int): Nivel de combinación (2 o 3).
+            r2_threshold (float): Umbral de R² para incluir una interacción.
+        """
+        self.graph.clear()  # Limpiar grafo existente
+
+        if level == 2:
+            # Considerar todas las combinaciones de 2 factores
+            for pair in combinations(self.all_factors, 2):
+                self.experiment.set_active_factors(list(pair))
+                self.experiment.fit_models()
+                r2 = (self.experiment.r2_variable1 + self.experiment.r2_variable2) / 2
+                if r2 >= r2_threshold:
+                    self.graph.add_edge(pair[0], pair[1], weight=r2)
+        elif level == 3:
+            # Identificar los 3 factores más relevantes
+            factor_r2 = {}
+            for factor in self.all_factors:
+                edges = [data['weight'] for u, v, data in self.graph.edges(data=True) if u == factor or v == factor]
+                factor_r2[factor] = sum(edges) / len(edges) if edges else 0
+
+            top_factors = sorted(factor_r2, key=factor_r2.get, reverse=True)[:3]
+
+            # Añadir únicamente las interacciones entre los 3 factores seleccionados
+            for pair in combinations(top_factors, 2):
+                self.experiment.set_active_factors(list(pair))
+                self.experiment.fit_models()
+                r2 = (self.experiment.r2_variable1 + self.experiment.r2_variable2) / 2
+                if r2 >= r2_threshold:
+                    self.graph.add_edge(pair[0], pair[1], weight=r2)
+        else:
+            raise ValueError("Nivel de combinación no soportado. Debe ser 2 o 3.")
 
     def visualize_graph(self, style='Style 1'):
         pos = nx.spring_layout(self.graph)
@@ -194,55 +213,80 @@ def analyze_design(level, pb_design, bb_design, variable1_values, variable2_valu
     experiment.set_dependent_variables(np.array(variable1_values, dtype=float), np.array(variable2_values, dtype=float))
 
     optimizer.set_matrices_and_values()
-    optimizer.build_graph(level=level)
+    optimizer.build_graph(level=level, r2_threshold=0.5)  # Ajusta el umbral según tus necesidades
     graph_image_path = optimizer.visualize_graph(style=style)
 
-    # Identificar los 3 factores más activos basados en R²
-    factor_r2 = {}
-    for factor in experiment.factor_values.keys():
-        # Filtrar las aristas que contienen el factor
-        edges = [data['weight'] for u, v, data in optimizer.graph.edges(data=True) if u == factor or v == factor]
-        factor_r2[factor] = sum(edges) / len(edges) if edges else 0
-
-    # Seleccionar los 3 factores con mayor R²
-    top_factors = sorted(factor_r2, key=factor_r2.get, reverse=True)[:3]
-
-    # Generar diseño Box-Behnken para los 3 factores
-    bb_design_3f = generate_box_behnken(top_factors)
-
-    # Simular datos de respuesta (puedes ajustar esta parte según tus necesidades)
-    # Aquí, simplemente generamos valores aleatorios para las respuestas
-    np.random.seed(42)  # Para reproducibilidad
-    simulated_response1 = np.random.uniform(0.1, 1.0, len(bb_design_3f))
-    simulated_response2 = np.random.uniform(0.1, 1.0, len(bb_design_3f))
-
-    # Crear dataframe de resultados
-    bb_results = []
-    for i, design in enumerate(bb_design_3f):
-        row = design.copy()
-        row['Response 1'] = round(simulated_response1[i], 3)
-        row['Response 2'] = round(simulated_response2[i], 3)
-        bb_results.append(row)
-
-    # Convertir bb_design_used a DataFrame para mostrar
     if level == 3:
-        # Diseño generado dinámicamente para los 3 factores más relevantes
+        # Identificar los 3 factores más activos basados en R²
+        factor_r2 = {}
+        for factor in experiment.factor_values.keys():
+            # Filtrar las aristas que contienen el factor
+            edges = [data['weight'] for u, v, data in optimizer.graph.edges(data=True) if u == factor or v == factor]
+            factor_r2[factor] = sum(edges) / len(edges) if edges else 0
+
+        # Seleccionar los 3 factores con mayor R²
+        top_factors = sorted(factor_r2, key=factor_r2.get, reverse=True)[:3]
+
+        # Generar diseño Box-Behnken para los 3 factores
+        bb_design_3f = generate_box_behnken(top_factors)
+
+        # Simular datos de respuesta (puedes ajustar esta parte según tus necesidades)
+        # Aquí, simplemente generamos valores aleatorios para las respuestas
+        np.random.seed(42)  # Para reproducibilidad
+        simulated_response1 = np.random.uniform(0.1, 1.0, len(bb_design_3f))
+        simulated_response2 = np.random.uniform(0.1, 1.0, len(bb_design_3f))
+
+        # Crear dataframe de resultados
+        bb_results = []
+        for i, design in enumerate(bb_design_3f):
+            row = design.copy()
+            row['Response 1'] = round(simulated_response1[i], 3)
+            row['Response 2'] = round(simulated_response2[i], 3)
+            bb_results.append(row)
+
+        # Convertir bb_design_used a DataFrame para mostrar
         bb_design_used = bb_design_3f
         headers = top_factors + ['Response 1', 'Response 2']
-    else:
+
+        # Crear DataFrame para la matriz Box-Behnken usada
+        df_bb_used = pd.DataFrame(bb_design_used)
+        # Agregar respuestas al DataFrame
+        df_bb_used[['Response 1', 'Response 2']] = pd.DataFrame(bb_results)[['Response 1', 'Response 2']]
+
+    elif level == 2:
         # Usar el diseño Box-Behnken ingresado por el usuario para 4 factores
         bb_design_used = []
         for row in bb_design:
             design_row = { 'X1': row[0], 'X2': row[1], 'X3': row[2], 'X4': row[3] }
             bb_design_used.append(design_row)
+        
+        # Simular datos de respuesta (puedes ajustar esta parte según tus necesidades)
+        # Aquí, simplemente generamos valores aleatorios para las respuestas
+        np.random.seed(42)  # Para reproducibilidad
+        simulated_response1 = np.random.uniform(0.1, 1.0, len(bb_design_used))
+        simulated_response2 = np.random.uniform(0.1, 1.0, len(bb_design_used))
+
+        # Crear dataframe de resultados
+        bb_results = []
+        for i, design in enumerate(bb_design_used):
+            row = design.copy()
+            row['Response 1'] = round(simulated_response1[i], 3)
+            row['Response 2'] = round(simulated_response2[i], 3)
+            bb_results.append(row)
+
         headers = ['X1', 'X2', 'X3', 'X4', 'Response 1', 'Response 2']
 
-    # Crear DataFrame para la matriz Box-Behnken usada
-    df_bb_used = pd.DataFrame(bb_design_used)
-    # Agregar respuestas al DataFrame
-    df_bb_used[['Response 1', 'Response 2']] = pd.DataFrame(bb_results)[['Response 1', 'Response 2']]
+        # Crear DataFrame para la matriz Box-Behnken usada
+        df_bb_used = pd.DataFrame(bb_design_used)
+        # Agregar respuestas al DataFrame
+        df_bb_used[['Response 1', 'Response 2']] = pd.DataFrame(bb_results)[['Response 1', 'Response 2']]
+    else:
+        return "Error: Nivel de combinación inválido. Debe ser 2 o 3.", None, None
+
+    # Crear DataFrame para los datos simulados
+    df_simulated = df_bb_used.copy()
 
-    return graph_image_path, df_bb_used, df_bb_used
+    return graph_image_path, df_bb_used, df_simulated
 
 # Matriz Plackett-Burman (por defecto)
 default_pb_design = [