Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import pandas as pd | |
| import numpy as np | |
| import matplotlib.pyplot as plt | |
| import seaborn as sns | |
| from scipy import stats | |
| from datetime import datetime | |
| import docx | |
| 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, n_replicas): | |
| valores_base = [1.00, 0.80, 0.60, 0.40, 0.20, 0.10, 0.05] | |
| if n_filas <= 7: | |
| solucion_inoculo = valores_base[:n_filas] | |
| agua = [round(1 - x, 2) for x in solucion_inoculo] | |
| else: | |
| solucion_inoculo = valores_base.copy() | |
| ultimo_valor = valores_base[-1] | |
| for _ in range(n_filas - 7): | |
| nuevo_valor = round(ultimo_valor / 2, 3) | |
| solucion_inoculo.append(nuevo_valor) | |
| ultimo_valor = nuevo_valor | |
| agua = [round(1 - x, 3) for x in solucion_inoculo] | |
| data = { | |
| f"Solución de inóculo ({concentracion_inicial} {unidad_medida})": solucion_inoculo, | |
| "H2O": agua | |
| } | |
| df = pd.DataFrame(data) | |
| nombre_columna = f"Solución de inóculo ({concentracion_inicial} {unidad_medida})" | |
| df["Factor de Dilución"] = df[nombre_columna].apply(lambda x: round(1 / x, 2)) | |
| df["Concentración Predicha Numérica"] = df["Factor de Dilución"].apply( | |
| lambda x: concentracion_inicial / x | |
| ) | |
| df[f"Concentración Predicha ({unidad_medida})"] = df["Concentración Predicha Numérica"].round(0).astype(str) | |
| # 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 | |
| # Las columnas de promedio y desviación estándar se agregarán durante el análisis | |
| return df | |
| def ajustar_decimales_evento(df, decimales): | |
| df = df.copy() | |
| # Ajustar decimales en todas las columnas numéricas | |
| for col in df.columns: | |
| try: | |
| df[col] = pd.to_numeric(df[col], errors='ignore') | |
| df[col] = df[col].round(decimales) | |
| except: | |
| pass | |
| return df | |
| 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') | |
| # Calcular el promedio y la desviación estándar | |
| df[f"Concentración Real Promedio ({unidad_medida})"] = df[col_replicas].mean(axis=1) | |
| 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, n_replicas, unidad_medida, palette_puntos, estilo_puntos, | |
| palette_linea_ajuste, estilo_linea_ajuste, | |
| palette_linea_ideal, estilo_linea_ideal, | |
| palette_barras_error, mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos): | |
| col_predicha_num = "Concentración Predicha Numérica" | |
| 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_promedio] = df_valid[col_real_promedio].astype(float) | |
| df_valid[col_desviacion] = df_valid[col_desviacion].fillna(0).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_promedio]) | |
| df_valid['Ajuste Lineal'] = intercept + slope * df_valid[col_predicha_num] | |
| # Configurar estilos | |
| sns.set(style="whitegrid") | |
| plt.rcParams.update({'figure.autolayout': True}) | |
| fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6)) | |
| # Obtener colores de las paletas | |
| colors_puntos = sns.color_palette(palette_puntos, as_cmap=False) | |
| colors_linea_ajuste = sns.color_palette(palette_linea_ajuste, as_cmap=False) | |
| colors_linea_ideal = sns.color_palette(palette_linea_ideal, as_cmap=False) | |
| colors_barras_error = sns.color_palette(palette_barras_error, as_cmap=False) | |
| # Seleccionar colores | |
| color_puntos = colors_puntos[0] | |
| color_linea_ajuste = colors_linea_ajuste[0] | |
| color_linea_ideal = colors_linea_ideal[0] | |
| color_barras_error = colors_barras_error[0] | |
| # Gráfico de dispersión con línea de regresión | |
| if mostrar_puntos: | |
| 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=estilo_puntos, | |
| color=color_puntos, | |
| ecolor=color_barras_error, | |
| elinewidth=2, | |
| capsize=3, | |
| label='Datos Reales' | |
| ) | |
| else: | |
| ax1.scatter( | |
| df_valid[col_predicha_num], | |
| df_valid[col_real_promedio], | |
| color=color_puntos, | |
| s=100, | |
| label='Datos Reales', | |
| marker=estilo_puntos | |
| ) | |
| # Línea de ajuste | |
| if mostrar_linea_ajuste: | |
| ax1.plot( | |
| df_valid[col_predicha_num], | |
| df_valid['Ajuste Lineal'], | |
| color=color_linea_ajuste, | |
| label='Ajuste Lineal', | |
| linewidth=2, | |
| linestyle=estilo_linea_ajuste | |
| ) | |
| # Línea ideal | |
| if mostrar_linea_ideal: | |
| min_predicha = df_valid[col_predicha_num].min() | |
| max_predicha = df_valid[col_predicha_num].max() | |
| ax1.plot( | |
| [min_predicha, max_predicha], | |
| [min_predicha, max_predicha], | |
| color=color_linea_ideal, | |
| linestyle=estilo_linea_ideal, | |
| label='Ideal' | |
| ) | |
| 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 Promedio', fontsize=12) | |
| # Añadir ecuación y R² en el gráfico | |
| ax1.annotate( | |
| f'y = {intercept:.2f} + {slope:.2f}x\n$R^2$ = {r_value**2:.4f}', | |
| xy=(0.05, 0.95), | |
| xycoords='axes fraction', | |
| fontsize=12, | |
| backgroundcolor='white', | |
| verticalalignment='top' | |
| ) | |
| # Posicionar la leyenda | |
| ax1.legend(loc='lower right', fontsize=10) | |
| # Gráfico de residuos | |
| residuos = df_valid[col_real_promedio] - df_valid['Ajuste Lineal'] | |
| ax2.scatter( | |
| df_valid[col_predicha_num], | |
| residuos, | |
| color=color_puntos, | |
| s=100, | |
| marker=estilo_puntos, | |
| label='Residuos' | |
| ) | |
| ax2.axhline(y=0, color='black', linestyle='--', linewidth=1) | |
| ax2.set_title('Gráfico de Residuos', fontsize=14) | |
| ax2.set_xlabel('Concentración Predicha', fontsize=12) | |
| ax2.set_ylabel('Residuo', fontsize=12) | |
| ax2.legend(loc='upper right', fontsize=10) | |
| plt.tight_layout() | |
| plt.savefig('grafico.png') # Guardar el gráfico para incluirlo en el informe | |
| return fig | |
| def evaluar_calidad_calibracion(df_valid, r_squared, rmse, cv_percent): | |
| """Evaluar la calidad de la calibración y proporcionar recomendaciones""" | |
| evaluacion = { | |
| "calidad": "", | |
| "recomendaciones": [], | |
| "estado": "✅" if r_squared >= 0.95 and cv_percent <= 15 else "⚠️" | |
| } | |
| if r_squared >= 0.95: | |
| evaluacion["calidad"] = "Excelente" | |
| elif r_squared >= 0.90: | |
| evaluacion["calidad"] = "Buena" | |
| elif r_squared >= 0.85: | |
| evaluacion["calidad"] = "Regular" | |
| else: | |
| evaluacion["calidad"] = "Deficiente" | |
| if r_squared < 0.95: | |
| evaluacion["recomendaciones"].append("- Considere repetir algunas mediciones para mejorar la correlación") | |
| if cv_percent > 15: | |
| evaluacion["recomendaciones"].append("- La variabilidad es alta. Revise el procedimiento de dilución") | |
| if rmse > 0.1 * df_valid[df_valid.columns[-1]].astype(float).mean(): | |
| evaluacion["recomendaciones"].append("- El error de predicción es significativo. Verifique la técnica de medición") | |
| return evaluacion | |
| 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_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_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_promedio]) | |
| r_squared = r_value ** 2 | |
| 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) | |
| informe = f"""# Informe de Calibración {evaluacion['estado']} | |
| Fecha: {datetime.now().strftime('%d/%m/%Y %H:%M')} | |
| ## Resumen Estadístico | |
| - **Ecuación de Regresión**: y = {intercept:.4f} + {slope:.4f}x | |
| - **Coeficiente de correlación (r)**: {r_value:.4f} | |
| - **Coeficiente de determinación ($R^2$)**: {r_squared:.4f} | |
| - **Valor p**: {p_value:.4e} | |
| - **Error estándar de la pendiente**: {std_err:.4f} | |
| - **Error cuadrático medio (RMSE)**: {rmse:.4f} | |
| - **Coeficiente de variación (CV)**: {cv:.2f}% | |
| ## Evaluación de Calidad | |
| - **Calidad de la calibración**: {evaluacion['calidad']} | |
| ## Recomendaciones | |
| {chr(10).join(evaluacion['recomendaciones']) if evaluacion['recomendaciones'] else "No hay recomendaciones específicas. La calibración cumple con los criterios de calidad."} | |
| ## Decisión | |
| {("✅ APROBADO - La calibración cumple con los criterios de calidad establecidos" if evaluacion['estado'] == "✅" else "⚠️ REQUIERE REVISIÓN - La calibración necesita ajustes según las recomendaciones anteriores")} | |
| --- | |
| *Nota: Este informe fue generado automáticamente. Por favor, revise los resultados y valide según sus criterios específicos.* | |
| """ | |
| return informe, evaluacion['estado'] | |
| 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", df | |
| # Calcular promedio y desviación estándar dependiendo de las réplicas | |
| df = calcular_promedio_desviacion(df, n_replicas, unidad_medida) | |
| col_predicha_num = "Concentración Predicha Numérica" | |
| col_real_promedio = f"Concentración Real Promedio ({unidad_medida})" | |
| # Convertir columnas a numérico | |
| df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], 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_promedio]) | |
| if len(df_valid) < 2: | |
| return "Se necesitan más datos", None, "Se requieren al menos dos valores reales para el análisis", df | |
| # 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_promedio]) | |
| df_valid['Ajuste Lineal'] = intercept + slope * df_valid[col_predicha_num] | |
| # Generar gráfico con opciones predeterminadas | |
| fig = generar_graficos( | |
| df_valid, n_replicas, unidad_medida, | |
| palette_puntos='deep', estilo_puntos='o', | |
| palette_linea_ajuste='muted', estilo_linea_ajuste='-', | |
| palette_linea_ideal='bright', estilo_linea_ideal='--', | |
| palette_barras_error='pastel', | |
| mostrar_linea_ajuste=True, mostrar_linea_ideal=True, mostrar_puntos=True | |
| ) | |
| informe, estado = generar_informe_completo(df_valid, n_replicas, unidad_medida) | |
| return estado, fig, informe, df | |
| def actualizar_graficos(df, n_replicas, unidad_medida, | |
| palette_puntos, estilo_puntos, | |
| palette_linea_ajuste, estilo_linea_ajuste, | |
| palette_linea_ideal, estilo_linea_ideal, | |
| palette_barras_error, | |
| mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos): | |
| if df is None or df.empty: | |
| return None | |
| # Asegurarse de que los cálculos estén actualizados | |
| df = calcular_promedio_desviacion(df, n_replicas, unidad_medida) | |
| col_predicha_num = "Concentración Predicha Numérica" | |
| col_real_promedio = f"Concentración Real Promedio ({unidad_medida})" | |
| # Convertir columnas a numérico | |
| df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], 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_promedio]) | |
| if len(df_valid) < 2: | |
| return None | |
| # Generar gráfico con opciones seleccionadas | |
| fig = generar_graficos( | |
| df_valid, n_replicas, unidad_medida, | |
| palette_puntos, estilo_puntos, | |
| palette_linea_ajuste, estilo_linea_ajuste, | |
| palette_linea_ideal, estilo_linea_ideal, | |
| palette_barras_error, | |
| mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos | |
| ) | |
| return fig | |
| def exportar_informe_word(df_valid, informe_md, unidad_medida): | |
| # Crear documento Word | |
| doc = docx.Document() | |
| # Estilos APA 7 | |
| style = doc.styles['Normal'] | |
| font = style.font | |
| font.name = 'Times New Roman' | |
| font.size = Pt(12) | |
| # Título centrado | |
| titulo = doc.add_heading('Informe de Calibración', 0) | |
| titulo.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER | |
| # Fecha | |
| fecha = doc.add_paragraph(f"Fecha: {datetime.now().strftime('%d/%m/%Y %H:%M')}") | |
| fecha.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER | |
| # Insertar gráfico | |
| if os.path.exists('grafico.png'): | |
| doc.add_picture('grafico.png', width=Inches(6)) | |
| ultimo_parrafo = doc.paragraphs[-1] | |
| ultimo_parrafo.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER | |
| # Leyenda del gráfico en estilo APA 7 | |
| leyenda = doc.add_paragraph('Figura 1. Gráfico de calibración.') | |
| leyenda_format = leyenda.paragraph_format | |
| leyenda_format.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER | |
| leyenda.style = doc.styles['Caption'] | |
| # Agregar contenido del informe | |
| doc.add_heading('Resumen Estadístico', level=1) | |
| for linea in informe_md.split('\n'): | |
| if linea.startswith('##'): | |
| doc.add_heading(linea.replace('##', '').strip(), level=2) | |
| else: | |
| doc.add_paragraph(linea) | |
| # Añadir tabla de datos | |
| doc.add_heading('Tabla de Datos de Calibración', level=1) | |
| # Convertir DataFrame a lista de listas | |
| tabla_datos = df_valid.reset_index(drop=True) | |
| tabla_datos = tabla_datos.round(4) # Redondear a 4 decimales si es necesario | |
| columnas = tabla_datos.columns.tolist() | |
| registros = tabla_datos.values.tolist() | |
| # Crear tabla en Word | |
| tabla = doc.add_table(rows=1 + len(registros), cols=len(columnas)) | |
| tabla.style = 'Table Grid' | |
| # Añadir los encabezados | |
| hdr_cells = tabla.rows[0].cells | |
| for idx, col_name in enumerate(columnas): | |
| hdr_cells[idx].text = col_name | |
| # Añadir los registros | |
| for i, registro in enumerate(registros): | |
| row_cells = tabla.rows[i + 1].cells | |
| for j, valor in enumerate(registro): | |
| row_cells[j].text = str(valor) | |
| # Formatear fuente de la tabla | |
| for row in tabla.rows: | |
| for cell in row.cells: | |
| for paragraph in cell.paragraphs: | |
| paragraph.style = doc.styles['Normal'] | |
| # Guardar documento | |
| filename = 'informe_calibracion.docx' | |
| doc.save(filename) | |
| return filename | |
| def exportar_informe_latex(df_valid, informe_md): | |
| # Generar código LaTeX | |
| informe_tex = r"""\documentclass{article} | |
| \usepackage[spanish]{babel} | |
| \usepackage{amsmath} | |
| \usepackage{graphicx} | |
| \usepackage{booktabs} | |
| \begin{document} | |
| """ | |
| informe_tex += informe_md.replace('#', '').replace('**', '\\textbf{').replace('*', '\\textit{') | |
| informe_tex += r""" | |
| \end{document} | |
| """ | |
| filename = 'informe_calibracion.tex' | |
| with open(filename, 'w') as f: | |
| f.write(informe_tex) | |
| return filename | |
| def exportar_word(df, informe_md, unidad_medida): | |
| df_valid = df.copy() | |
| col_predicha_num = "Concentración Predicha Numérica" | |
| 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_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce') | |
| 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, 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_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_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce') | |
| df_valid = df_valid.dropna(subset=[col_predicha_num, col_real_promedio]) | |
| if df_valid.empty: | |
| return None | |
| filename = exportar_informe_latex(df_valid, informe_md) | |
| return filename # Retornamos el nombre del archivo | |
| # Funciones de ejemplo | |
| 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(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(n_replicas): | |
| df = generar_tabla(7, 2000000, "UFC", n_replicas) | |
| return ( | |
| 2000000, # Concentración Inicial | |
| "UFC", # Unidad de Medida | |
| 7, # Número de filas | |
| df, # Tabla Output | |
| "", # Estado Output | |
| None, # Gráficos Output | |
| "" # Informe Output | |
| ) | |
| def generar_datos_sinteticos_evento(df, n_replicas, unidad_medida): | |
| df = df.copy() | |
| col_predicha_num = "Concentración Predicha Numérica" | |
| # 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, n_replicas): | |
| # Actualizar tabla sin borrar "Concentración Real" | |
| 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 and 'Promedio' not in col and 'Desviación' not in col] | |
| col_real_old = [col for col in df.columns if 'Concentración Real' in col and 'Promedio' not in col and 'Desviación' not in col] | |
| # Reemplazar valores existentes en "Concentración Real" | |
| 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 | |
| def cargar_excel(file): | |
| # Leer el archivo Excel | |
| df = pd.read_excel(file.name, sheet_name=None) | |
| # Verificar que el archivo tenga al menos dos pestañas | |
| if len(df) < 2: | |
| return "El archivo debe tener al menos dos pestañas.", None, None, None, None, None, None | |
| # Obtener la primera pestaña como referencia | |
| primera_pestaña = next(iter(df.values())) | |
| concentracion_inicial = primera_pestaña.iloc[0, 0] | |
| unidad_medida = primera_pestaña.columns[0].split('(')[-1].split(')')[0] | |
| n_filas = len(primera_pestaña) | |
| n_replicas = len(df) | |
| # Generar la tabla base | |
| df_base = generar_tabla(n_filas, concentracion_inicial, unidad_medida, n_replicas) | |
| # Llenar la tabla con los datos de cada pestaña | |
| for i, (sheet_name, sheet_df) in enumerate(df.items(), start=1): | |
| col_real = f"Concentración Real {i} ({unidad_medida})" | |
| df_base[col_real] = sheet_df.iloc[:, 1].values | |
| return concentracion_inicial, unidad_medida, n_filas, n_replicas, df_base, "", None, "" | |
| # Interfaz Gradio | |
| with gr.Blocks(theme=gr.themes.Soft()) as interfaz: | |
| gr.Markdown(""" | |
| # 📊 Sistema Avanzado de Calibración con Análisis Estadístico | |
| Configure los parámetros, edite los valores en la tabla y luego presione "Calcular" para obtener el análisis. | |
| """) | |
| with gr.Tab("📝 Datos de Calibración"): | |
| with gr.Row(): | |
| concentracion_input = gr.Number( | |
| value=2000000, | |
| label="Concentración Inicial", | |
| precision=0 | |
| ) | |
| unidad_input = gr.Textbox( | |
| value="UFC", | |
| label="Unidad de Medida", | |
| placeholder="UFC, OD, etc..." | |
| ) | |
| filas_slider = gr.Slider( | |
| minimum=1, | |
| maximum=20, | |
| value=7, | |
| step=1, | |
| label="Número de filas" | |
| ) | |
| decimales_slider = gr.Slider( | |
| minimum=0, | |
| maximum=5, | |
| value=0, | |
| step=1, | |
| label="Número de Decimales" | |
| ) | |
| replicas_slider = gr.Slider( | |
| minimum=1, | |
| maximum=10, | |
| value=1, | |
| step=1, | |
| label="Número de Réplicas" | |
| ) | |
| with gr.Row(): | |
| calcular_btn = gr.Button("🔄 Calcular", variant="primary") | |
| limpiar_btn = gr.Button("🗑 Limpiar Datos", variant="secondary") | |
| ajustar_decimales_btn = gr.Button("🛠 Ajustar Decimales", variant="secondary") | |
| with gr.Row(): | |
| ejemplo_ufc_btn = gr.Button("📋 Cargar Ejemplo UFC", variant="secondary") | |
| ejemplo_od_btn = gr.Button("📋 Cargar Ejemplo OD", variant="secondary") | |
| sinteticos_btn = gr.Button("🧪 Generar Datos Sintéticos", variant="secondary") | |
| cargar_excel_btn = gr.UploadButton("📂 Cargar Excel", file_types=[".xlsx"], variant="secondary") | |
| tabla_output = gr.DataFrame( | |
| wrap=True, | |
| label="Tabla de Datos", | |
| interactive=True, | |
| type="pandas", | |
| ) | |
| with gr.Tab("📊 Análisis y Reporte"): | |
| estado_output = gr.Textbox(label="Estado", interactive=False) | |
| graficos_output = gr.Plot(label="Gráficos de Análisis") | |
| # Opciones y botones debajo del gráfico | |
| with gr.Row(): | |
| # Paletas de colores disponibles en Seaborn | |
| paletas_colores = ["deep", "muted", "pastel", "bright", "dark", "colorblind", "Set1", "Set2", "Set3"] | |
| palette_puntos_dropdown = gr.Dropdown( | |
| choices=paletas_colores, | |
| value="deep", | |
| label="Paleta para Puntos" | |
| ) | |
| estilo_puntos_dropdown = gr.Dropdown( | |
| choices=["o", "s", "^", "D", "v", "<", ">", "h", "H", "p", "*", "X", "d"], | |
| value="o", | |
| label="Estilo de Puntos" | |
| ) | |
| palette_linea_ajuste_dropdown = gr.Dropdown( | |
| choices=paletas_colores, | |
| value="muted", | |
| label="Paleta Línea de Ajuste" | |
| ) | |
| estilo_linea_ajuste_dropdown = gr.Dropdown( | |
| choices=["-", "--", "-.", ":"], | |
| value="-", | |
| label="Estilo Línea de Ajuste" | |
| ) | |
| with gr.Row(): | |
| palette_linea_ideal_dropdown = gr.Dropdown( | |
| choices=paletas_colores, | |
| value="bright", | |
| label="Paleta Línea Ideal" | |
| ) | |
| estilo_linea_ideal_dropdown = gr.Dropdown( | |
| choices=["--", "-", "-.", ":"], | |
| value="--", | |
| label="Estilo Línea Ideal" | |
| ) | |
| palette_barras_error_dropdown = gr.Dropdown( | |
| choices=paletas_colores, | |
| value="pastel", | |
| label="Paleta Barras de Error" | |
| ) | |
| mostrar_linea_ajuste = gr.Checkbox(value=True, label="Mostrar Línea de Ajuste") | |
| mostrar_linea_ideal = gr.Checkbox(value=True, label="Mostrar Línea Ideal") | |
| mostrar_puntos = gr.Checkbox(value=True, label="Mostrar Puntos") | |
| graficar_btn = gr.Button("📊 Graficar", variant="primary") | |
| with gr.Row(): | |
| copiar_btn = gr.Button("📋 Copiar Informe", variant="secondary") | |
| exportar_word_btn = gr.Button("💾 Exportar Informe Word", variant="primary") | |
| exportar_latex_btn = gr.Button("💾 Exportar Informe LaTeX", variant="primary") | |
| with gr.Row(): | |
| exportar_word_file = gr.File(label="Informe en Word") | |
| exportar_latex_file = gr.File(label="Informe en LaTeX") | |
| # Informe al final | |
| informe_output = gr.Markdown(elem_id="informe_output") | |
| # Eventos | |
| input_components = [tabla_output] | |
| output_components = [estado_output, graficos_output, informe_output, tabla_output] | |
| # Evento al presionar el botón Calcular | |
| calcular_btn.click( | |
| fn=actualizar_analisis, | |
| inputs=[tabla_output, replicas_slider, unidad_input], | |
| outputs=output_components | |
| ) | |
| # Evento para graficar con opciones seleccionadas | |
| graficar_btn.click( | |
| fn=actualizar_graficos, | |
| inputs=[ | |
| tabla_output, replicas_slider, unidad_input, | |
| palette_puntos_dropdown, estilo_puntos_dropdown, | |
| palette_linea_ajuste_dropdown, estilo_linea_ajuste_dropdown, | |
| palette_linea_ideal_dropdown, estilo_linea_ideal_dropdown, | |
| palette_barras_error_dropdown, | |
| mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos | |
| ], | |
| outputs=graficos_output | |
| ) | |
| # Evento para limpiar datos | |
| limpiar_btn.click( | |
| fn=limpiar_datos, | |
| 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, replicas_slider, unidad_input], | |
| outputs=tabla_output | |
| ) | |
| # Evento para cargar archivo Excel | |
| cargar_excel_btn.upload( | |
| fn=cargar_excel, | |
| inputs=[cargar_excel_btn], | |
| outputs=[concentracion_input, unidad_input, filas_slider, replicas_slider, tabla_output, estado_output, graficos_output, informe_output] | |
| ) | |
| # Evento al presionar el botón Ajustar Decimales | |
| ajustar_decimales_btn.click( | |
| fn=ajustar_decimales_evento, | |
| inputs=[tabla_output, decimales_slider], | |
| outputs=tabla_output | |
| ) | |
| # 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_wrapper, | |
| inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider], | |
| outputs=tabla_output | |
| ) | |
| unidad_input.change( | |
| fn=actualizar_tabla_wrapper, | |
| inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider], | |
| outputs=tabla_output | |
| ) | |
| filas_slider.change( | |
| 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 | |
| ) | |
| # No agregamos un evento para decimales_slider.change, para evitar borrar la columna "Concentración Real" | |
| # Evento de copiar informe utilizando JavaScript | |
| copiar_btn.click( | |
| None, | |
| [], | |
| [], | |
| js=""" | |
| function() { | |
| const informeElement = document.querySelector('#informe_output'); | |
| const range = document.createRange(); | |
| range.selectNode(informeElement); | |
| window.getSelection().removeAllRanges(); | |
| window.getSelection().addRange(range); | |
| document.execCommand('copy'); | |
| window.getSelection().removeAllRanges(); | |
| alert('Informe copiado al portapapeles'); | |
| } | |
| """ | |
| ) | |
| # Eventos de exportar informes | |
| exportar_word_btn.click( | |
| fn=exportar_word, | |
| inputs=[tabla_output, informe_output, unidad_input], | |
| outputs=exportar_word_file | |
| ) | |
| exportar_latex_btn.click( | |
| fn=exportar_latex, | |
| inputs=[tabla_output, informe_output], | |
| outputs=exportar_latex_file | |
| ) | |
| # Inicializar la interfaz con el ejemplo base | |
| def iniciar_con_ejemplo(): | |
| 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, df = actualizar_analisis(df, n_replicas, "UFC") | |
| return ( | |
| 2000000, | |
| "UFC", | |
| 7, | |
| df, | |
| estado, | |
| fig, | |
| informe | |
| ) | |
| interfaz.load( | |
| fn=iniciar_con_ejemplo, | |
| outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output] | |
| ) | |
| # Lanzar la interfaz | |
| if __name__ == "__main__": | |
| interfaz.launch() | |