Update app.py

app.py

@@ -10,7 +10,7 @@ from docx.shared import Inches, Pt
 from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
 import os
 
-def generar_tabla(n_filas, concentracion_inicial, unidad_medida):
+def generar_tabla(n_filas, concentracion_inicial, unidad_medida, n_replicas):
     valores_base = [1.00, 0.80, 0.60, 0.40, 0.20, 0.10, 0.05]
 
     if n_filas <= 7:
@@ -37,7 +37,17 @@ def generar_tabla(n_filas, concentracion_inicial, unidad_medida):
         lambda x: concentracion_inicial / x
     )
     df[f"Concentración Predicha ({unidad_medida})"] = df["Concentración Predicha Numérica"].round(0).astype(str)
-    df[f"Concentración Real ({unidad_medida})"] = None
+
+    # Añadir columnas para las réplicas de "Concentración Real"
+    for i in range(1, n_replicas + 1):
+        df[f"Concentración Real {i} ({unidad_medida})"] = None
+
+    # Añadir columnas para promedio y desviación estándar si hay más de una réplica
+    if n_replicas > 1:
+        df[f"Concentración Real Promedio ({unidad_medida})"] = None
+        df[f"Desviación Estándar ({unidad_medida})"] = None
+    else:
+        df[f"Concentración Real Promedio ({unidad_medida})"] = None
 
     return df
 
@@ -55,30 +65,36 @@ def ajustar_decimales_evento(df, decimales):
 
     return df
 
-def generar_datos_sinteticos(df, desviacion_std):
-    col_predicha_num = "Concentración Predicha Numérica"
-    col_real = [col for col in df.columns if 'Real' in col][0]
+def calcular_promedio_desviacion(df, n_replicas, unidad_medida):
+    df = df.copy()
+    # Obtener las columnas de réplicas
+    col_replicas = [f"Concentración Real {i} ({unidad_medida})" for i in range(1, n_replicas + 1)]
+    # Convertir a numérico
+    for col in col_replicas:
+        df[col] = pd.to_numeric(df[col], errors='coerce')
 
-    # Generar datos sintéticos
-    valores_predichos = df[col_predicha_num].astype(float).values
-    datos_sinteticos = valores_predichos + np.random.normal(0, desviacion_std, size=len(valores_predichos))
-    datos_sinteticos = np.maximum(0, datos_sinteticos)  # Asegurar que no haya valores negativos
-    datos_sinteticos = np.round(datos_sinteticos, 2)
+    # Calcular el promedio y la desviación estándar
+    df[f"Concentración Real Promedio ({unidad_medida})"] = df[col_replicas].mean(axis=1)
 
-    df[col_real] = datos_sinteticos
+    if n_replicas > 1:
+        df[f"Desviación Estándar ({unidad_medida})"] = df[col_replicas].std(ddof=1, axis=1)
+    else:
+        df[f"Desviación Estándar ({unidad_medida})"] = 0.0
 
     return df
 
-def generar_graficos(df_valid):
+def generar_graficos(df_valid, n_replicas, unidad_medida):
     col_predicha_num = "Concentración Predicha Numérica"
-    col_real = [col for col in df_valid.columns if 'Real' in col][0]
+    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
+    col_desviacion = f"Desviación Estándar ({unidad_medida})"
 
     # Convertir a numérico
     df_valid[col_predicha_num] = df_valid[col_predicha_num].astype(float)
-    df_valid[col_real] = df_valid[col_real].astype(float)
+    df_valid[col_real_promedio] = df_valid[col_real_promedio].astype(float)
+    df_valid[col_desviacion] = df_valid[col_desviacion].astype(float)
 
     # Calcular regresión lineal
-    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real])
+    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real_promedio])
     df_valid['Ajuste Lineal'] = intercept + slope * df_valid[col_predicha_num]
 
     # Configurar estilos
@@ -88,16 +104,30 @@ def generar_graficos(df_valid):
     fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))
 
     # Gráfico de dispersión con línea de regresión
-    sns.scatterplot(
-        data=df_valid,
-        x=col_predicha_num,
-        y=col_real,
-        ax=ax1,
-        color='blue',
-        s=100,
-        label='Datos Reales',
-        marker='o'
-    )
+    if n_replicas > 1:
+        # Incluir barras de error
+        ax1.errorbar(
+            df_valid[col_predicha_num],
+            df_valid[col_real_promedio],
+            yerr=df_valid[col_desviacion],
+            fmt='o',
+            color='blue',
+            ecolor='lightgray',
+            elinewidth=3,
+            capsize=0,
+            label='Datos Reales'
+        )
+    else:
+        sns.scatterplot(
+            data=df_valid,
+            x=col_predicha_num,
+            y=col_real_promedio,
+            ax=ax1,
+            color='blue',
+            s=100,
+            label='Datos Reales',
+            marker='o'
+        )
 
     # Línea de ajuste
     sns.lineplot(
@@ -122,7 +152,7 @@ def generar_graficos(df_valid):
 
     ax1.set_title('Correlación entre Concentración Predicha y Real', fontsize=14)
     ax1.set_xlabel('Concentración Predicha', fontsize=12)
-    ax1.set_ylabel('Concentración Real', fontsize=12)
+    ax1.set_ylabel('Concentración Real Promedio', fontsize=12)
 
     # Añadir ecuación y R² en el gráfico
     ax1.annotate(
@@ -138,7 +168,7 @@ def generar_graficos(df_valid):
     ax1.legend(loc='lower right', fontsize=10)
 
     # Gráfico de residuos
-    residuos = df_valid[col_real] - df_valid['Ajuste Lineal']
+    residuos = df_valid[col_real_promedio] - df_valid['Ajuste Lineal']
     sns.scatterplot(
         data=df_valid,
         x=col_predicha_num,
@@ -188,20 +218,20 @@ def evaluar_calidad_calibracion(df_valid, r_squared, rmse, cv_percent):
 
     return evaluacion
 
-def generar_informe_completo(df_valid):
+def generar_informe_completo(df_valid, n_replicas, unidad_medida):
     """Generar un informe completo en formato markdown"""
     col_predicha_num = "Concentración Predicha Numérica"
-    col_real = [col for col in df_valid.columns if 'Real' in col][0]
+    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
 
     # Convertir a numérico
     df_valid[col_predicha_num] = df_valid[col_predicha_num].astype(float)
-    df_valid[col_real] = df_valid[col_real].astype(float)
+    df_valid[col_real_promedio] = df_valid[col_real_promedio].astype(float)
 
     # Calcular estadísticas
-    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real])
+    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real_promedio])
     r_squared = r_value ** 2
-    rmse = np.sqrt(((df_valid[col_real] - (intercept + slope * df_valid[col_predicha_num])) ** 2).mean())
-    cv = (df_valid[col_real].std() / df_valid[col_real].mean()) * 100  # CV de los valores reales
+    rmse = np.sqrt(((df_valid[col_real_promedio] - (intercept + slope * df_valid[col_predicha_num])) ** 2).mean())
+    cv = (df_valid[col_real_promedio].std() / df_valid[col_real_promedio].mean()) * 100  # CV de los valores reales
 
     # Evaluar calidad
     evaluacion = evaluar_calidad_calibracion(df_valid, r_squared, rmse, cv)
@@ -232,32 +262,35 @@ Fecha: {datetime.now().strftime('%d/%m/%Y %H:%M')}
 """
     return informe, evaluacion['estado']
 
-def actualizar_analisis(df):
+def actualizar_analisis(df, n_replicas, unidad_medida):
     if df is None or df.empty:
         return "Error en los datos", None, "No se pueden generar análisis"
 
     col_predicha_num = "Concentración Predicha Numérica"
-    col_real = [col for col in df.columns if 'Real' in col][0]
+    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
+
+    # Calcular promedio y desviación estándar
+    df = calcular_promedio_desviacion(df, n_replicas, unidad_medida)
 
     # Convertir columnas a numérico
     df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
-    df[col_real] = pd.to_numeric(df[col_real], errors='coerce')
+    df[col_real_promedio] = pd.to_numeric(df[col_real_promedio], errors='coerce')
 
-    df_valid = df.dropna(subset=[col_predicha_num, col_real])
+    df_valid = df.dropna(subset=[col_predicha_num, col_real_promedio])
 
     if len(df_valid) < 2:
         return "Se necesitan más datos", None, "Se requieren al menos dos valores reales para el análisis"
 
     # Calcular la regresión y agregar 'Ajuste Lineal'
-    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real])
+    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real_promedio])
     df_valid['Ajuste Lineal'] = intercept + slope * df_valid[col_predicha_num]
 
-    fig = generar_graficos(df_valid)
-    informe, estado = generar_informe_completo(df_valid)
+    fig = generar_graficos(df_valid, n_replicas, unidad_medida)
+    informe, estado = generar_informe_completo(df_valid, n_replicas, unidad_medida)
 
     return estado, fig, informe
 
-def exportar_informe_word(df_valid, informe_md):
+def exportar_informe_word(df_valid, informe_md, unidad_medida):
     # Crear documento Word
     doc = docx.Document()
 
@@ -348,34 +381,34 @@ def exportar_informe_latex(df_valid, informe_md):
         f.write(informe_tex)
     return filename
 
-def exportar_word(df, informe_md):
+def exportar_word(df, informe_md, unidad_medida):
     df_valid = df.copy()
     col_predicha_num = "Concentración Predicha Numérica"
-    col_real = [col for col in df_valid.columns if 'Real' in col][0]
+    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
 
     # Convertir columnas a numérico
     df_valid[col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
-    df_valid[col_real] = pd.to_numeric(df_valid[col_real], errors='coerce')
+    df_valid[col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
 
-    df_valid = df_valid.dropna(subset=[col_predicha_num, col_real])
+    df_valid = df_valid.dropna(subset=[col_predicha_num, col_real_promedio])
 
     if df_valid.empty:
         return None
 
-    filename = exportar_informe_word(df_valid, informe_md)
+    filename = exportar_informe_word(df_valid, informe_md, unidad_medida)
 
     return filename  # Retornamos el nombre del archivo
 
 def exportar_latex(df, informe_md):
     df_valid = df.copy()
     col_predicha_num = "Concentración Predicha Numérica"
-    col_real = [col for col in df_valid.columns if 'Real' in col][0]
+    col_real_promedio = [col for col in df_valid.columns if 'Real Promedio' in col][0]
 
     # Convertir columnas a numérico
     df_valid[col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
-    df_valid[col_real] = pd.to_numeric(df_valid[col_real], errors='coerce')
+    df_valid[col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
 
-    df_valid = df_valid.dropna(subset=[col_predicha_num, col_real])
+    df_valid = df_valid.dropna(subset=[col_predicha_num, col_real_promedio])
 
     if df_valid.empty:
         return None
@@ -385,20 +418,28 @@ def exportar_latex(df, informe_md):
     return filename  # Retornamos el nombre del archivo
 
 # Funciones de ejemplo
-def cargar_ejemplo_ufc():
-    df = generar_tabla(7, 2000000, "UFC")
-    valores_reales = [2000000, 1600000, 1200000, 800000, 400000, 200000, 100000]
-    df[f"Concentración Real (UFC)"] = valores_reales
+def cargar_ejemplo_ufc(n_replicas):
+    df = generar_tabla(7, 2000000, "UFC", n_replicas)
+    # Valores reales de ejemplo
+    for i in range(1, n_replicas + 1):
+        valores_reales = [2000000 - (i - 1) * 10000, 1600000 - (i - 1) * 8000, 1200000 - (i - 1) * 6000,
+                          800000 - (i - 1) * 4000, 400000 - (i - 1) * 2000, 200000 - (i - 1) * 1000,
+                          100000 - (i - 1) * 500]
+        df[f"Concentración Real {i} (UFC)"] = valores_reales
     return 2000000, "UFC", 7, df
 
-def cargar_ejemplo_od():
-    df = generar_tabla(7, 1.0, "OD")
-    valores_reales = [1.000, 0.800, 0.600, 0.400, 0.200, 0.100, 0.050]
-    df[f"Concentración Real (OD)"] = valores_reales
+def cargar_ejemplo_od(n_replicas):
+    df = generar_tabla(7, 1.0, "OD", n_replicas)
+    # Valores reales de ejemplo
+    for i in range(1, n_replicas + 1):
+        valores_reales = [1.00 - (i - 1) * 0.05, 0.80 - (i - 1) * 0.04, 0.60 - (i - 1) * 0.03,
+                          0.40 - (i - 1) * 0.02, 0.20 - (i - 1) * 0.01, 0.10 - (i - 1) * 0.005,
+                          0.05 - (i - 1) * 0.002]
+        df[f"Concentración Real {i} (OD)"] = valores_reales
     return 1.0, "OD", 7, df
 
-def limpiar_datos():
-    df = generar_tabla(7, 2000000, "UFC")
+def limpiar_datos(n_replicas):
+    df = generar_tabla(7, 2000000, "UFC", n_replicas)
     return (
         2000000,   # Concentración Inicial
         "UFC",     # Unidad de Medida
@@ -409,27 +450,37 @@ def limpiar_datos():
         ""         # Informe Output
     )
 
-def generar_datos_sinteticos_evento(df):
+def generar_datos_sinteticos_evento(df, n_replicas, unidad_medida):
     df = df.copy()
     col_predicha_num = "Concentración Predicha Numérica"
-    df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
-    desviacion_std = 0.05 * df[col_predicha_num].mean()  # 5% de la media como desviación estándar
-    df = generar_datos_sinteticos(df, desviacion_std)
+
+    # Generar datos sintéticos para cada réplica
+    for i in range(1, n_replicas + 1):
+        col_real = f"Concentración Real {i} ({unidad_medida})"
+        df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
+        desviacion_std = 0.05 * df[col_predicha_num].mean()  # 5% de la media como desviación estándar
+        valores_predichos = df[col_predicha_num].astype(float).values
+        datos_sinteticos = valores_predichos + np.random.normal(0, desviacion_std, size=len(valores_predichos))
+        datos_sinteticos = np.maximum(0, datos_sinteticos)  # Asegurar que no haya valores negativos
+        datos_sinteticos = np.round(datos_sinteticos, 2)
+        df[col_real] = datos_sinteticos
+
     return df
 
-def actualizar_tabla_evento(df, n_filas, concentracion, unidad):
+def actualizar_tabla_evento(df, n_filas, concentracion, unidad, n_replicas):
     # Actualizar tabla sin borrar "Concentración Real"
-    df_new = generar_tabla(n_filas, concentracion, unidad)
+    df_new = generar_tabla(n_filas, concentracion, unidad, n_replicas)
 
     # Mapear columnas
-    col_real_new = [col for col in df_new.columns if 'Concentración Real' in col][0]
-    col_real_old = [col for col in df.columns if 'Concentración Real' in col][0]
+    col_real_new = [col for col in df_new.columns if 'Concentración Real' in col]
+    col_real_old = [col for col in df.columns if 'Concentración Real' in col]
 
     # Reemplazar valores existentes en "Concentración Real"
-    df_new[col_real_new] = None
-    for idx in df_new.index:
-        if idx in df.index:
-            df_new.at[idx, col_real_new] = df.at[idx, col_real_old]
+    for col_new, col_old in zip(col_real_new, col_real_old):
+        df_new[col_new] = None
+        for idx in df_new.index:
+            if idx in df.index:
+                df_new.at[idx, col_new] = df.at[idx, col_old]
 
     return df_new
 
@@ -466,6 +517,13 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
                 step=1,
                 label="Número de Decimales"
             )
+            replicas_slider = gr.Slider(
+                minimum=1,
+                maximum=5,
+                value=1,
+                step=1,
+                label="Número de Réplicas"
+            )
 
         with gr.Row():
             calcular_btn = gr.Button("🔄 Calcular", variant="primary")
@@ -479,11 +537,11 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
 
         tabla_output = gr.DataFrame(
             row_count=(1, "dynamic"),
-            col_count=(6, "fixed"),
+            col_count=(6, "dynamic"),
             wrap=True,
             label="Tabla de Datos",
             interactive=True,
-            datatype=["number", "number", "number", "number", "str", "number"],
+            datatype="auto",
             type="pandas",
         )
 
@@ -507,32 +565,34 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
     # Evento al presionar el botón Calcular
     calcular_btn.click(
         fn=actualizar_analisis,
-        inputs=tabla_output,
+        inputs=[tabla_output, replicas_slider, unidad_input],
         outputs=output_components
     )
 
     # Evento para limpiar datos
     limpiar_btn.click(
         fn=limpiar_datos,
-        inputs=[],
+        inputs=[replicas_slider],
         outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output]
     )
 
     # Eventos de los botones de ejemplo
     ejemplo_ufc_btn.click(
         fn=cargar_ejemplo_ufc,
+        inputs=[replicas_slider],
         outputs=[concentracion_input, unidad_input, filas_slider, tabla_output]
     )
 
     ejemplo_od_btn.click(
         fn=cargar_ejemplo_od,
+        inputs=[replicas_slider],
         outputs=[concentracion_input, unidad_input, filas_slider, tabla_output]
     )
 
     # Evento para generar datos sintéticos
     sinteticos_btn.click(
         fn=generar_datos_sinteticos_evento,
-        inputs=tabla_output,
+        inputs=[tabla_output, replicas_slider, unidad_input],
         outputs=tabla_output
     )
 
@@ -544,21 +604,30 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
     )
 
     # Actualizar tabla al cambiar los parámetros (sin borrar "Concentración Real")
+    def actualizar_tabla_wrapper(df, filas, conc, unidad, replicas):
+        return actualizar_tabla_evento(df, filas, conc, unidad, replicas)
+
     concentracion_input.change(
-        fn=actualizar_tabla_evento,
-        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input],
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider],
         outputs=tabla_output
     )
 
     unidad_input.change(
-        fn=actualizar_tabla_evento,
-        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input],
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider],
         outputs=tabla_output
     )
 
     filas_slider.change(
-        fn=actualizar_tabla_evento,
-        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input],
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider],
+        outputs=tabla_output
+    )
+
+    replicas_slider.change(
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider],
         outputs=tabla_output
     )
 
@@ -586,7 +655,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
     # Eventos de exportar informes
     exportar_word_btn.click(
         fn=exportar_word,
-        inputs=[tabla_output, informe_output],
+        inputs=[tabla_output, informe_output, unidad_input],
         outputs=exportar_word_file
     )
 
@@ -598,10 +667,11 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
 
     # Inicializar la interfaz con el ejemplo base
     def iniciar_con_ejemplo():
-        df = generar_tabla(7, 2000000, "UFC")
-        valores_reales = [2000000, 1600000, 1200000, 800000, 400000, 200000, 100000]
-        df[f"Concentración Real (UFC)"] = valores_reales
-        estado, fig, informe = actualizar_analisis(df)
+        n_replicas = 1
+        df = generar_tabla(7, 2000000, "UFC", n_replicas)
+        # Valores reales de ejemplo
+        df[f"Concentración Real 1 (UFC)"] = [2000000, 1600000, 1200000, 800000, 400000, 200000, 100000]
+        estado, fig, informe = actualizar_analisis(df, n_replicas, "UFC")
         return (
             2000000,
             "UFC",