Skip to contents

Llega la entrega de febrero de una tabla que ya se revisó en enero. ¿Qué cambió? Y si se mide todos los meses, ¿la calidad mejora o empeora?

En esta guía:

Las 2 entregas de la misma tabla

La entrega de enero es datos_operativos. La de febrero se arma a partir de ella, con 4 cambios:

  • otros 2 canales llegan como "S/D";
  • un código de usuario también llega como "S/D";
  • el monto de la fila 4, que en enero era el centinela -99, llega corregido;
  • aparece una columna nueva, sucursal.
library(lupa)

enero <- datos_operativos
febrero <- datos_operativos
febrero$canal[c(2, 7)] <- "S/D"
febrero$codigo_usuario[6] <- "S/D"
febrero$monto[4] <- 1500
febrero$sucursal <- "central"

🔎 Qué cambió entre las 2 entregas

Cada entrega se perfila con su fecha y con el mismo nombre, entrega. Es el nombre de la tabla en las mediciones de más abajo. comparar_perfiles() no exige que las 2 tengan las mismas columnas.

perfil_enero <- perfilar(enero, nombre = "entrega", fecha = "2026-01-31")
perfil_febrero <- perfilar(febrero, nombre = "entrega", fecha = "2026-02-28")
deriva <- comparar_perfiles(perfil_enero, perfil_febrero)
deriva[, c("columna", "aspecto", "cambio", "severidad")]
#>           columna      aspecto     cambio  severidad
#> 1        sucursal      columna  aparecida      error
#> 2  codigo_usuario    faltantes modificado sospechoso
#> 3  codigo_usuario cardinalidad modificado sospechoso
#> 4           canal    faltantes modificado sospechoso
#> 5           canal cardinalidad modificado sospechoso
#> 6           monto    faltantes modificado         ok
#> 7           monto        rango modificado         ok
#> 8           canal  vocabulario modificado sospechoso
#> 9  codigo_usuario       patron modificado sospechoso
#> 10 codigo_usuario       patron modificado sospechoso
#> 11          canal       patron modificado sospechoso
#> 12          canal       patron modificado sospechoso
#> 13 codigo_usuario     hallazgo  aparecido sospechoso
#> 14       sucursal     hallazgo  aparecido sospechoso
#> 15          monto     hallazgo   resuelto         ok

Cada fila es un cambio, y aspecto dice de qué tipo. La columna nueva es un cambio de esquema (columna, aparecida). Las demás filas son cambios sobre columnas que están en las 2 entregas:

  • la proporción de faltantes;
  • la cardinalidad;
  • el rango;
  • los patrones de formato;
  • los hallazgos que aparecieron o se resolvieron.

severidad es un factor ordenado, ok < sospechoso < error, así que la tabla se filtra como cualquier otra. Los cambios menores quedan como filas ok: no desaparecen. Estos son los faltantes que empeoraron:

peores <- deriva[deriva$severidad >= "sospechoso" & deriva$aspecto == "faltantes", ]
peores[, c("columna", "aspecto", "evidencia")]
#>          columna   aspecto                           evidencia
#> 2 codigo_usuario faltantes Cambio de +0.0769 en escala [0, 1].
#> 4          canal faltantes Cambio de +0.1538 en escala [0, 1].

La comparación usa las propiedades medidas de cada columna, no los valores uno por uno. Un perfil comparado consigo mismo no produce ningún cambio:

nrow(comparar_perfiles(perfil_enero, perfil_enero))
#> [1] 0

Lo que la protección de datos personales tapa no se compara. Queda declarado en el atributo campos_protegidos de la deriva; el detalle está en el artículo Alcance y cobertura.

Un cambio real o una diferencia de redondeo

A veces la pregunta no es qué cambió en los datos, sino si 2 procesos produjeron lo mismo. Por ejemplo:

  • la tabla que exporta un sistema nuevo frente a la del que reemplaza;
  • la misma consulta corrida en 2 motores.

En este ejemplo, el sistema nuevo guarda un monto con menos decimales y trae una fila más, vacía.

sistema_anterior <- data.frame(monto = c(1250, 1600, 1425.0004, 1750, 1810))
sistema_nuevo <- data.frame(monto = c(1250, 1600, 1425, 1750, 1810, NA))
perfil_anterior <- perfilar(
  sistema_anterior, fecha = "2026-01-31", analizar_dependencias = FALSE
)
perfil_nuevo <- perfilar(
  sistema_nuevo, fecha = "2026-01-31", analizar_dependencias = FALSE
)
equivalencia <- comparar_equivalencia(
  perfil_anterior, perfil_nuevo, tolerancia = 0.01
)
table(equivalencia$veredicto)
#> 
#>               identico            equivalente materialmente_distinto 
#>                     41                      2                      7 
#>          no_comparable 
#>                     23

comparar_equivalencia() devuelve una fila por columna y campo compartidos. Los conteos se comparan con igualdad exacta. La tolerancia la declara quien compara. Sólo vale para los campos de punto flotante, como la media y el desvío. Un campo sin valor medible en los 2 lados queda como no_comparable y no cuenta como acuerdo.

campos <- c("n", "n_faltantes", "maximo", "media", "desvio")
equivalencia[
  match(campos, equivalencia$campo),
  c("campo", "valor_anterior", "valor_actual", "veredicto", "tipo_eje")
]
#>          campo valor_anterior valor_actual              veredicto tipo_eje
#> 3            n              5            6 materialmente_distinto   exacto
#> 8  n_faltantes              0            1 materialmente_distinto   exacto
#> 33      maximo           1810         1810               identico   exacto
#> 34       media     1567.00008         1567            equivalente flotante
#> 36      desvio   231.4518.... 231.4519....            equivalente flotante

En la salida:

  • la fila de más es un cambio real: n y n_faltantes salen materialmente_distinto;
  • la media y el desvío se movieron por el redondeo y salen equivalente, dentro de la tolerancia;
  • el máximo no cambió.

En los ejes exactos, equivalente es inalcanzable: el conteo cambiado sigue siendo materialmente_distinto con cualquier tolerancia.

tolerancias <- c(0, 0.01, 0.5, 10)
veredicto_n <- vapply(tolerancias, function(tolerancia) {
  comparacion <- comparar_equivalencia(perfil_anterior, perfil_nuevo, tolerancia)
  as.character(comparacion$veredicto[comparacion$campo == "n"])
}, character(1))
data.frame(tolerancia = tolerancias, veredicto_n = veredicto_n)
#>   tolerancia            veredicto_n
#> 1       0.00 materialmente_distinto
#> 2       0.01 materialmente_distinto
#> 3       0.50 materialmente_distinto
#> 4      10.00 materialmente_distinto

La tolerancia se publica en cada fila y no entra en ninguna regla del paquete: el comparador devuelve datos, no decisiones.

Una diferencia entre 2 evaluaciones

Para seguir la calidad medida, y no sólo el perfil, se repite cada mes la evaluación de 7. Del hallazgo a la métrica. Mide la completitud de las columnas con faltantes disfrazados, agregada por columna y comparada con un 90 %. El modelo sale de la propuesta de enero y queda fijo. Si se recalculara con cada entrega, una diferencia podría venir del modelo y no de los datos.

propuesta <- proponer_modelo(perfil_enero, enero)
propuesta$incluir <- propuesta$metrica == "NoNulo"
modelo_completitud <- modelo_desde_propuesta(propuesta)
publicable <- perfil_evaluacion(
  "Publicable",
  regla_evaluacion("Completitud de al menos 90 %", function(x) x >= 0.9)
)

evaluar_entrega <- function(datos, id_medicion, fecha) {
  medicion <- medir(
    modelo_completitud, datos, id_medicion = id_medicion, fecha = fecha
  )
  evaluar(agregar(medicion, "atributo", "ratio"), publicable)
}
evaluacion_enero <- evaluar_entrega(enero, "enero", "2026-01-31")
evaluacion_febrero <- evaluar_entrega(febrero, "febrero", "2026-02-28")

cambio <- comparar_evaluaciones(evaluacion_enero, evaluacion_febrero)
cambio[, c("perfil", "resultado_anterior", "resultado_actual", "delta")]
#>       perfil resultado_anterior resultado_actual delta
#> 1 Publicable               0.75              0.5 -0.25

En enero, 3 de las 4 columnas alcanzaban el 90 %. En febrero lo alcanzan 2, porque canal y codigo_usuario sumaron faltantes disfrazados. El monto corregido no alcanza a compensarlo: ya cumplía. Si 2 corridas no se pudieran comparar, por ejemplo porque cambió el modelo, la columna comparacion diría por qué falta el delta.

Una serie de corridas

Llega marzo, con los canales y el código de usuario corregidos. Para más de 2 corridas, historico_calidad() reúne las evaluaciones en un data.frame plano y versionado:

marzo <- febrero
marzo$canal[c(2, 5, 7)] <- c("telefono", "web", "telefono")
marzo$codigo_usuario[6] <- "USR-006"
evaluacion_marzo <- evaluar_entrega(marzo, "marzo", "2026-03-31")

historico <- historico_calidad(
  evaluacion_enero, evaluacion_febrero, evaluacion_marzo
)
historico[, c("id_medicion", "fecha", "nivel", "resultado")]
#>   id_medicion      fecha             nivel resultado
#> 1       enero 2026-01-31  evaluacion_regla      0.75
#> 2       enero 2026-01-31 evaluacion_perfil      0.75
#> 3     febrero 2026-02-28  evaluacion_regla      0.50
#> 4     febrero 2026-02-28 evaluacion_perfil      0.50
#> 5       marzo 2026-03-31  evaluacion_regla      1.00
#> 6       marzo 2026-03-31 evaluacion_perfil      1.00

Cada corrida deja una fila por regla y una por perfil. El histórico se puede escribir como CSV o llevarse a una tabla de base de datos sin desarmar listas anidadas.

Cada corrida lleva su configuración: la tabla, el marco y los tipos de resultado. La configuración viaja en las columnas identidad_tabla y configuracion_* de las filas evaluacion_perfil. Por eso un histórico releído de un CSV separa las tablas y corta los cambios de marco igual que el objeto original.

detectar_deriva_calidad() compara corridas consecutivas, ordenadas por fecha dentro de cada perfil. Marca los cambios que superan el umbral en la escala [0, 1]:

saltos <- detectar_deriva_calidad(historico, umbral = 0.05)
saltos[, c("id_medicion_anterior", "id_medicion_actual", "delta", "direccion",
           "severidad")]
#>   id_medicion_anterior id_medicion_actual delta direccion severidad
#> 1                enero            febrero -0.25 deterioro     error
#> 2              febrero              marzo  0.50    mejora        ok

La caída de febrero es un deterioro, con severidad error y el mismo delta que dio comparar_evaluaciones(). La recuperación de marzo es una mejora, con severidad ok.

Guardar y ampliar el histórico

En el uso de todos los meses, el histórico se guarda y se amplía con cada corrida. acumular_historico() agrega la nueva y no duplica una corrida idéntica:

hasta_febrero <- historico_calidad(evaluacion_enero, evaluacion_febrero)
ampliado <- acumular_historico(hasta_febrero, evaluacion_marzo)
identical(ampliado, historico)
#> [1] TRUE
nrow(acumular_historico(historico, evaluacion_marzo)) == nrow(historico)
#> [1] TRUE

La persistencia usa RDS y no agrega dependencias. guardar_historico() no reemplaza un archivo existente salvo que se pida con sobrescribir = TRUE:

archivo <- tempfile(fileext = ".rds")
guardar_historico(historico, archivo)
identical(leer_historico(archivo), historico)
#> [1] TRUE
tryCatch(guardar_historico(historico, archivo), error = conditionMessage)
#> [1] "El archivo ya existe; usar `sobrescribir = TRUE` para reemplazarlo."
unlink(archivo)

Resumen

  • comparar_perfiles() compara 2 entregas sin exigir las mismas columnas y separa los cambios de esquema de los cambios sobre columnas comparables.
  • comparar_equivalencia() aplica la tolerancia declarada sólo a los campos de punto flotante: un conteo distinto es siempre materialmente_distinto.
  • Para comparar evaluaciones, el modelo y la regla quedan fijos y cada corrida lleva su id_medicion y su fecha.
  • historico_calidad() reúne las corridas en una tabla plana, y detectar_deriva_calidad() marca los deterioros y las mejoras entre corridas consecutivas.
  • acumular_historico() y guardar_historico() mantienen la serie entre sesiones.

🧭 Paso siguiente

10. Perfilar una base: el mismo examen dentro de un motor de base de datos, eligiendo cuánto de la tabla se trae a R.