Update app.py

app.py

@@ -3,6 +3,10 @@ os.system('pip install gradio seaborn scipy scikit-learn openpyxl networkx pydan
 
 from pydantic import BaseModel, ConfigDict
 
+class YourModel(BaseModel):
+    class Config:
+        arbitrary_types_allowed = True
+
 import numpy as np
 import networkx as nx
 import matplotlib.pyplot as plt
@@ -12,7 +16,6 @@ from sklearn.preprocessing import PolynomialFeatures
 from sklearn.metrics import r2_score
 from itertools import combinations
 import tempfile
-import pandas as pd
 
 # Clase para el modelo de regresión
 class RegressionModel:
@@ -29,7 +32,7 @@ class RegressionModel:
         X_poly = self.poly.transform(X)
         return self.model.predict(X_poly)
 
-    def r2_score_calc(self, X, y):
+    def r2_score(self, X, y):
         y_pred = self.predict(X)
         return r2_score(y, y_pred)
 
@@ -68,8 +71,8 @@ class ExperimentalDesign:
         self.model_variable1.fit(X, self.variable1_values)
         self.model_variable2.fit(X, self.variable2_values)
 
-        self.r2_variable1 = self.model_variable1.r2_score_calc(X, self.variable1_values)
-        self.r2_variable2 = self.model_variable2.r2_score_calc(X, self.variable2_values)
+        self.r2_variable1 = self.model_variable1.r2_score(X, self.variable1_values)
+        self.r2_variable2 = self.model_variable2.r2_score(X, self.variable2_values)
 
 # Clase para el análisis de teoría de grafos
 class GraphTheoryAnalysis:
@@ -81,48 +84,16 @@ class GraphTheoryAnalysis:
     def set_matrices_and_values(self):
         self.all_factors = list(self.experiment.factor_values.keys())
 
-    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.
-        """
-        if level not in [2, 3]:
-            raise ValueError("Nivel de combinación no soportado. Debe ser 2 o 3.")
-
-        self.graph.clear()  # Limpiar grafo existente
-
-        if level >= 2:
-            # Construir interacciones de nivel 2
-            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)
-
-        if level == 3:
-            # Calcular R² acumulado por factor
-            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
-
-            # Seleccionar los 3 factores con mayor R²
-            top_factors = sorted(factor_r2, key=factor_r2.get, reverse=True)[:3]
+    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
 
-            # Limpiar el grafo para incluir solo las interacciones entre los 3 factores
-            self.graph.clear()
-
-            # Añadir interacciones entre los 3 factores seleccionados
-            for pair in combinations(top_factors, 2):
+        for pair in combinations(self.all_factors, level):
+            if len(pair) >= 2:  # Asegurarse de que hay suficientes elementos para formar un par
                 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)
+                self.graph.add_edge(pair[0], pair[1], weight=r2)
 
     def visualize_graph(self, style='Style 1'):
         pos = nx.spring_layout(self.graph)
@@ -154,12 +125,9 @@ class GraphTheoryAnalysis:
         nx.draw_networkx_labels(self.graph, pos, font_size=font_size)
 
         edge_weights = [self.graph[u][v]['weight'] for u, v in self.graph.edges()]
-        # Normalizar el ancho de las líneas para mejor visualización
-        max_weight = max(edge_weights) if edge_weights else 1
-        normalized_weights = [weight / max_weight * 5 for weight in edge_weights]
-        nx.draw_networkx_edges(self.graph, pos, width=normalized_weights, edge_color=edge_color)
+        nx.draw_networkx_edges(self.graph, pos, width=edge_weights, edge_color=edge_color)
 
-        edge_labels = { (u, v): f"{d['weight']:.2f}" for u, v, d in self.graph.edges(data=True) }
+        edge_labels = nx.get_edge_attributes(self.graph, 'weight')
         nx.draw_networkx_edge_labels(self.graph, pos, edge_labels=edge_labels, font_size=font_size)
 
         plt.title(f"Grafo de relaciones entre factores basado en R² ({style})")
@@ -173,38 +141,8 @@ class GraphTheoryAnalysis:
         
         return temp_file.name
 
-# Función para generar el diseño Box-Behnken para 3 factores
-def generate_box_behnken(factors):
-    # Box-Behnken design for 3 factors
-    bb_design_3f = [
-        [-1, -1,  0],
-        [ 1, -1,  0],
-        [-1,  1,  0],
-        [ 1,  1,  0],
-        [-1,  0, -1],
-        [ 1,  0, -1],
-        [-1,  0,  1],
-        [ 1,  0,  1],
-        [ 0, -1, -1],
-        [ 0,  1, -1],
-        [ 0, -1,  1],
-        [ 0,  1,  1]
-    ]
-    design = []
-    for row in bb_design_3f:
-        design.append(dict(zip(factors, row)))
-    return design
-
 # Definición de la interfaz de Gradio
 def analyze_design(level, pb_design, bb_design, variable1_values, variable2_values, style):
-    # Validar y convertir matrices de diseño a numpy arrays
-    try:
-        pb_design_np = np.array(pb_design, dtype=float)
-        bb_design_np = np.array(bb_design, dtype=float)
-    except ValueError:
-        return "Error: Asegúrate de que las matrices de diseño contienen solo números.", None, None
-
-    # Inicializar diseño experimental
     experiment = ExperimentalDesign(regression_degree=2)
     optimizer = GraphTheoryAnalysis(experiment)
     
@@ -215,85 +153,14 @@ def analyze_design(level, pb_design, bb_design, variable1_values, variable2_valu
         'X4': [0.05, 0.5]
     }
 
-    experiment.set_design(pb_design_np, bb_design_np)
+    experiment.set_design(np.array(pb_design), np.array(bb_design))
     experiment.set_factors(factor_values)
-    experiment.set_dependent_variables(np.array(variable1_values, dtype=float), np.array(variable2_values, dtype=float))
+    experiment.set_dependent_variables(np.array(variable1_values), np.array(variable2_values))
 
     optimizer.set_matrices_and_values()
-    optimizer.build_graph(level=level, r2_threshold=0.5)  # Ajusta el umbral según tus necesidades
+    optimizer.build_graph(level=level)
     graph_image_path = optimizer.visualize_graph(style=style)
-
-    if level == 3:
-        # 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']
-
-        # 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']]
-    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_simulated
+    return graph_image_path, bb_design
 
 # Matriz Plackett-Burman (por defecto)
 default_pb_design = [
@@ -307,7 +174,7 @@ default_pb_design = [
     [-1, -1, -1, -1]
 ]
 
-# Matriz Box-Behnken (por defecto) para 4 factores
+# Matriz Box-Behnken (por defecto)
 default_bb_design = [
     [-1, -1, 0, 0],
     [1, -1, 0, 0],
@@ -344,52 +211,16 @@ default_variable2_values = [0.362, 0.856, 0.177, 0.261, 0.946, 0.695, 0.892, 0.0
 interface = gr.Interface(
     fn=analyze_design,
     inputs=[
-        gr.Slider(2, 3, step=1, label="Nivel de Combinación (2 o 3)", value=3),
-        gr.Dataframe(
-            headers=["X1", "X2", "X3", "X4"], 
-            value=default_pb_design, 
-            label="Matriz 1 (Plackett-Burman)", 
-            datatype=["number"]*4,
-            row_count=(8, "fixed"),
-            col_count=(4, "fixed")
-        ),
-        gr.Dataframe(
-            headers=["X1", "X2", "X3", "X4"], 
-            value=default_bb_design, 
-            label="Matriz 2 (Box-Behnken)", 
-            datatype=["number"]*4,
-            row_count=(25, "fixed"),
-            col_count=(4, "fixed")
-        ),
-        gr.Dataframe(
-            headers=["Variable 1"], 
-            value=[[val] for val in default_variable1_values], 
-            label="Valores de Variable 1",
-            datatype=["number"],
-            row_count=(8, "fixed"),
-            col_count=(1, "fixed")
-        ),
-        gr.Dataframe(
-            headers=["Variable 2"], 
-            value=[[val] for val in default_variable2_values], 
-            label="Valores de Variable 2",
-            datatype=["number"],
-            row_count=(8, "fixed"),
-            col_count=(1, "fixed")
-        ),
-        gr.Dropdown(
-            ["Style 1", "Style 2", "Style 3", "Style 4"], 
-            label="Estilo del Grafo", 
-            value="Style 1"
-        )
-    ],
-    outputs=[
-        gr.Image(label="Grafo de Relaciones entre Factores"),
-        gr.Dataframe(label="Matriz Box-Behnken Usada"),
-        gr.Dataframe(label="Datos Simulados para Box-Behnken")
+        gr.Slider(1, 4, step=1, label="Level of Combination (1 to 4)"),
+        gr.Dataframe(headers=["X1", "X2", "X3", "X4"], value=default_pb_design, label="Matrix 1 (Plackett-Burman)"),
+        gr.Dataframe(headers=["X1", "X2", "X3", "X4"], value=default_bb_design, label="Matrix 2 (Box-Behnken)"),
+        gr.Dataframe(headers=["Variable 1"], value=[[val] for val in default_variable1_values], label="Variable 1 Values"),
+        gr.Dataframe(headers=["Variable 2"], value=[[val] for val in default_variable2_values], label="Variable 2 Values"),
+        gr.Dropdown(["Style 1", "Style 2", "Style 3", "Style 4"], label="Graph Style", value="Style 1")
     ],
-    title="Análisis de Teoría de Grafos para Diseño Experimental",
-    description="Analiza y visualiza las relaciones entre factores en un diseño experimental usando teoría de grafos. Además, genera y presenta datos simulados para un diseño Box-Behnken de 3 factores."
+    outputs=["image", "dataframe"],
+    title="Graph Theory Analysis for Experimental Design",
+    description="Analyze and visualize the relationships between factors in an experimental design using graph theory."
 )
 
 # Ejecutar la interfaz