Implementando un Framework de Calidad de Datos con Python: Estrategias Prácticas y Herramientas para un Análisis Fiable

¡Hola a todos! Como buen entusiasta de los datos, siempre estoy buscando la manera de mejorar mis proyectos y asegurar que mis análisis sean lo más robustos posible. Hoy quiero compartirles algo fundamental en el mundo de la ciencia de datos: la implementación de un framework de calidad de datos. Si alguna vez te has encontrado luchando con datos inconsistentes, incompletos o incorrectos, sabes lo frustrante que puede ser y cómo puede minar la confianza en tus resultados. Por eso, he decidido bucear en este tema y mostrarte cómo podemos construir y aplicar un framework sólido usando herramientas de Python.

En este artículo, mi objetivo es desmitificar qué es un framework de calidad de datos, por qué es crucial para cualquier proyecto de análisis y cómo podemos utilizar algunas de las herramientas más potentes de Python para ponerlo en práctica. Te guiaré a través de las dimensiones clave de la calidad de datos y te mostraré un ejemplo práctico con un dataset real, identificando problemas y aplicando soluciones.

La Importancia de la Calidad de Datos para la Toma de Decisiones

Permítanme ser directo: sin calidad de datos, no hay confianza en los datos, y sin confianza, las decisiones basadas en ellos son, en el mejor de los casos, arriesgadas, y en el peor, desastrosas. En un mundo donde los datos se han convertido en el nuevo oro, su pureza es tan valiosa como su cantidad. Imaginemos que estamos construyendo un modelo predictivo para la retención de clientes; si los datos de entrada están llenos de errores, valores faltantes o inconsistencias, el modelo, por muy sofisticado que sea, producirá predicciones erróneas. Esto no solo lleva a malas decisiones de negocio, sino que también puede erosionar la credibilidad de todo el equipo de ciencia de datos.

Un framework de calidad de datos nos proporciona un enfoque estructurado para identificar, medir, monitorear y mejorar la calidad de nuestros datos a lo largo de su ciclo de vida. No es solo una tarea técnica; es una disciplina estratégica que garantiza que los datos sean aptos para el propósito, es decir, que sean adecuados para apoyar los objetivos de negocio y la toma de decisiones informada. Es la base sobre la que se construyen análisis significativos, modelos predictivos precisos y estrategias empresariales exitosas.

La Importancia de la Calidad de Datos para la Toma de Decisiones

Dimensiones de la Calidad de Datos y Herramientas de Python

Para abordar la calidad de los datos de manera efectiva, primero debemos entender qué la define. No se trata de un concepto monolítico, sino de un conjunto de características que, en conjunto, determinan cuán “buenos” son nuestros datos para un propósito específico. A continuación, exploraremos las dimensiones clave que utilizo en mis proyectos:

Dimensiones Clave de la Calidad de Datos

Completitud (Completeness): ¿Faltan valores en nuestros datos? Un dato es completo si todos los valores esperados están presentes y registrados. Por ejemplo, si un campo como “Edad” tiene muchos valores nulos, su completitud es baja.
Unicidad (Uniqueness): ¿Existen duplicados en nuestros registros? La unicidad asegura que cada entidad se representa una sola vez en el dataset. Los registros duplicados pueden sesgar análisis y modelos.
Validez (Validity): ¿Los datos se ajustan a un formato, tipo o rango predefinido? La validez verifica que los datos cumplan con las reglas de negocio y las restricciones de formato. Por ejemplo, una edad no puede ser negativa o una fecha debe seguir un formato específico.
Consistencia (Consistency): ¿Los datos son coherentes en diferentes fuentes o a lo largo del tiempo? La consistencia se refiere a la uniformidad de los datos. Si un cliente tiene diferentes direcciones en dos tablas relacionadas, hay una inconsistencia.
Precisión (Accuracy): ¿Los datos reflejan la realidad? La precisión mide qué tan correctos o verdaderos son los datos en comparación con la fuente original o la realidad. Un error tipográfico en un nombre o un valor incorrecto en una medida reducen la precisión.
Puntualidad (Timeliness): ¿Los datos están disponibles cuando se necesitan y están actualizados? En muchos escenarios, los datos pierden valor rápidamente si no son actuales. Un informe de ventas de ayer es más puntual que uno de hace un mes.

Herramientas de Python para la Calidad de Datos

Python nos ofrece un ecosistema rico en librerías que facilitan la implementación de cheques de calidad de datos. Aquí les presento dos de mis favoritas, que combinan flexibilidad y potencia:

Great Expectations

¿Qué es? Great Expectations (GE) es una herramienta de código abierto que nos permite validar, documentar y perfilar nuestros datos. Su filosofía central es la “Expectativa”: definimos lo que esperamos de nuestros datos (ej., “la columna ‘edad’ no debería tener valores nulos”, “la columna ‘género’ solo debe contener ‘Masculino’ o ‘Femenino’”). GE luego verifica si estas expectativas se cumplen y genera informes detallados y visualizaciones que facilitan la comprensión de la calidad de los datos.

¿Cuándo usarla? Es ideal para proyectos de ciencia de datos a gran escala, equipos colaborativos y en pipelines de datos complejos. GE no solo valida los datos, sino que también actúa como una forma de comunicación y documentación viva sobre la calidad de los datos en tu proyecto. Si necesitas un historial de validaciones, perfiles de datos automáticos y una forma robusta de asegurar que los datos de entrada a tus modelos siempre cumplen ciertas reglas, Great Expectations es una excelente elección.

Pandera

¿Qué es? Pandera es una librería de validación de datos inspirada en las funcionalidades de tipado estático, pero aplicada directamente a los DataFrames de Pandas. Nos permite definir esquemas de validación de datos de manera programática, especificando tipos de datos, rangos, patrones de expresiones regulares, unicidad y otras restricciones para columnas y el índice de un DataFrame. Si los datos no cumplen con el esquema definido, Pandera lanza errores claros.

¿Cuándo usarla? La uso frecuentemente cuando necesito una validación rápida e integrada directamente en mi código Python. Es perfecta para asegurar la calidad de los datos en etapas tempranas de un script o un flujo de trabajo, o cuando se espera que un DataFrame siempre adhiera a una “forma” o “contrato” específico. Su integración con Pandas es muy natural, lo que la convierte en una herramienta muy eficiente para científicos de datos y analistas que ya trabajan intensamente con esta librería.

Ambas herramientas, aunque con enfoques ligeramente diferentes, comparten el objetivo de hacer la calidad de datos una parte integral de nuestro proceso de desarrollo y análisis. Ahora que conocemos las dimensiones y las herramientas, ¡es hora de ensuciarnos las manos!

La Importancia de la Calidad de Datos para la Toma de Decisiones

Dimensiones de la Calidad de Datos y Herramientas de Python

Dimensiones Clave de la Calidad de Datos

Completitud (Completeness): ¿Faltan valores en nuestros datos? Un dato es completo si todos los valores esperados están presentes y registrados. Por ejemplo, si un campo como “Edad” tiene muchos valores nulos, su completitud es baja.
Unicidad (Uniqueness): ¿Existen duplicados en nuestros registros? La unicidad asegura que cada entidad se representa una sola vez en el dataset. Los registros duplicados pueden sesgar análisis y modelos.
Validez (Validity): ¿Los datos se ajustan a un formato, tipo o rango predefinido? La validez verifica que los datos cumplan con las reglas de negocio y las restricciones de formato. Por ejemplo, una edad no puede ser negativa o una fecha debe seguir un formato específico.
Consistencia (Consistency): ¿Los datos son coherentes en diferentes fuentes o a lo largo del tiempo? La consistencia se refiere a la uniformidad de los datos. Si un cliente tiene diferentes direcciones en dos tablas relacionadas, hay una inconsistencia.
Precisión (Accuracy): ¿Los datos reflejan la realidad? La precisión mide qué tan correctos o verdaderos son los datos en comparación con la fuente original o la realidad. Un error tipográfico en un nombre o un valor incorrecto en una medida reducen la precisión.
Puntualidad (Timeliness): ¿Los datos están disponibles cuando se necesitan y están actualizados? En muchos escenarios, los datos pierden valor rápidamente si no son actuales. Un informe de ventas de ayer es más puntual que uno de hace un mes.

Herramientas de Python para la Calidad de Datos

Python nos ofrece un ecosistema rico en librerías que facilitan la implementación de cheques de calidad de datos. Aquí les presento dos de mis favoritas, que combinan flexibilidad y potencia:

Great Expectations

Pandera

Implementación Práctica: Mejorando la Calidad del Dataset Titanic

Para ilustrar cómo aplicar estos conceptos y herramientas, he elegido un dataset clásico y muy conocido en el mundo de la ciencia de datos: el dataset del Titanic. Este conjunto de datos, disponible fácilmente a través de la librería `seaborn`, es perfecto porque presenta varios problemas de calidad de datos comunes que nos permitirán poner en práctica lo aprendido.

Carga y Exploración Inicial del Dataset

Primero, carguemos el dataset y realicemos una exploración inicial para identificar algunos problemas de calidad.

import seaborn as sns
import pandas as pd

# Cargar el dataset del Titanic
df_titanic = sns.load_dataset('titanic')

# Mostrar las primeras filas
print("Primeras 5 filas del dataset Titanic:")
print(df_titanic.head())

# Obtener información general del DataFrame
print("\nInformación general del dataset:")
print(df_titanic.info())

# Contar valores nulos por columna
print("\nValores nulos por columna:")
print(df_titanic.isnull().sum())

Si observamos la salida de `df_titanic.info()` y `df_titanic.isnull().sum()`, notaremos rápidamente algunos problemas de calidad:

La columna ‘Age’ (Edad) tiene muchos valores nulos (177 de 891 registros). Esto afecta la completitud.
La columna ‘Embarked’ (Puerto de embarque) también tiene algunos valores nulos (2 de 891 registros), aunque menos críticos.
La columna ‘Cabin’ (Cabina) está en una situación mucho peor, con la gran mayoría de sus valores nulos. Su completitud es muy baja.
Podríamos asumir que ‘Sex’ (Género) solo debería tener ‘male’ o ‘female’, y que ‘Survived’ (Sobrevivió) debería ser 0 o 1. Estos son aspectos de validez.
Las edades no deberían ser negativas o excesivamente altas (validez).

Validación de Calidad de Datos con Pandera

Ahora, utilicemos Pandera para definir un esquema de validación para nuestro dataset. Esto nos permitirá establecer expectativas sobre los tipos de datos, la ausencia de nulos y los rangos de valores esperados.

import pandera as pa
from pandera import Column, DataFrameSchema, Check

# Definir el esquema de validación para el dataset Titanic
schema_titanic = DataFrameSchema(
    columns={
        "survived": Column(int, Check.isin([0, 1]), nullable=False), # Sobrevivió: 0 o 1, no nulo
        "pclass": Column(int, Check.isin([1, 2, 3]), nullable=False), # Clase: 1, 2 o 3, no nulo
        "sex": Column(str, Check.isin(["male", "female"]), nullable=False), # Sexo: 'male' o 'female', no nulo
        "age": Column(float, Check.in_range(0, 100), nullable=True), # Edad: flotante entre 0 y 100, puede ser nulo
        "sibsp": Column(int, Check.in_range(0, 10), nullable=False), # Hermanos/Cónyuges: entero, no nulo
        "parch": Column(int, Check.in_range(0, 10), nullable=False), # Padres/Hijos: entero, no nulo
        "fare": Column(float, Check.greater_than_or_equal_to(0), nullable=False), # Tarifa: flotante >= 0, no nulo
        "embarked": Column(str, Check.isin(["C", "Q", "S"]), nullable=True), # Puerto de embarque: 'C', 'Q', 'S', puede ser nulo
        "class": Column(str, Check.isin(["First", "Second", "Third"]), nullable=False), # Clase como string, no nulo
        "who": Column(str, Check.isin(["man", "woman", "child"]), nullable=False), # Quién: 'man', 'woman', 'child', no nulo
        "adult_male": Column(bool, nullable=False), # Adulto masculino: booleano, no nulo
        "deck": Column(str, nullable=True), # Cubierta: string, puede ser nulo
        "embark_town": Column(str, Check.isin(["Cherbourg", "Queenstown", "Southampton"]), nullable=True), # Ciudad de embarque: string, puede ser nulo
        "alive": Column(str, Check.isin(["yes", "no"]), nullable=False), # Vivo: 'yes' o 'no', no nulo
        "alone": Column(bool, nullable=False), # Solo: booleano, no nulo
    },
    strict=True # Asegura que no haya columnas extra no definidas en el esquema
)

try:
    # Validar el DataFrame contra el esquema
    schema_titanic.validate(df_titanic, lazy=True)
    print("\n¡El DataFrame cumple con el esquema de Pandera!")
except pa.errors.SchemaErrors as err:
    print("\nErrores de validación de Pandera detectados:")
    print(err.failure_cases) # Mostrar los casos que no cumplen las expectativas
    print(err.data) # Mostrar el DataFrame original para contexto

En este ejemplo, definí un esquema detallado. Notarán que he marcado `age`, `embarked`, `deck` y `embark_town` como `nullable=True`, ya que sabemos que tienen valores nulos y mi intención aquí no es eliminarlos en la validación, sino reconocer que pueden estar ausentes. Si quisiera forzar su completitud, pondría `nullable=False`. La opción `lazy=True` es muy útil porque permite que Pandera recopile todos los errores de validación antes de lanzar la excepción, en lugar de detenerse en el primer error. Esto me da una visión completa de dónde se encuentran los problemas.

Validación de Calidad de Datos con Great Expectations

Great Expectations toma un enfoque un poco más estructurado, creando un “Data Context” y suites de expectativas. Para este ejemplo, simularé el proceso de definir y ejecutar una suite de expectativas directamente en código para mostrar su potencial.

import great_expectations as ge
import great_expectations.jupyter_ux

# Convertir el DataFrame de pandas a un objeto Great Expectations
# Esto permite usar las funciones de expectativa directamente
ge_df_titanic = ge.from_pandas(df_titanic)

# Crear una suite de expectativas
# En un entorno real, esto se haría a través de `great_expectations suite new`
# y luego editando el archivo de la suite. Aquí lo construimos en memoria.
suite = ge_df_titanic.create_expectation_suite(
    "titanic_data_quality_suite"
)

# Añadir expectativas al DataFrame
# Expectativas de Completitud
ge_df_titanic.expect_column_values_to_not_be_null("pclass")
ge_df_titanic.expect_column_values_to_not_be_null("sex")
ge_df_titanic.expect_column_values_to_not_be_null("survived")

# Expectativas de Validez (rangos y valores permitidos)
ge_df_titanic.expect_column_values_to_be_of_type("age", "float")
ge_df_titanic.expect_column_values_to_be_between("age", min_value=0, max_value=100)
ge_df_titanic.expect_column_values_to_be_in_set("sex", ["male", "female"])
ge_df_titanic.expect_column_values_to_be_in_set("embarked", ["C", "Q", "S", None]) # Incluimos None por los nulos
ge_df_titanic.expect_column_values_to_be_between("fare", min_value=0, max_value=520) # Fare tiene un máximo de ~512

# Expectativas de Unicidad (si aplicara a alguna columna, por ejemplo, un ID único)
# ge_df_titanic.expect_column_values_to_be_unique("passenger_id") # No tenemos un ID único en este dataset

# Guardar la suite (en un entorno real, se guardaría en el disco)
ge_df_titanic.save_expectation_suite(discard_failed_expectations=False)

# Ejecutar la validación
results = ge_df_titanic.validate()

# Imprimir un resumen de los resultados
print("\nResultados de la validación con Great Expectations:")
print(f"Éxito general: {results['success']}")
print("Detalle de las expectativas:")
for res in results['results']:
    print(f"- Expectativa: {res['expectation_config']['expectation_type']} "
          f"| Columna: {res['expectation_config']['kwargs'].get('column', 'N/A')} "
          f"| Éxito: {res['success']} "
          f"| Detalles: {res['result']}")

# Si quieres ver los Data Docs (HTML interactivo), en un entorno real lo lanzarías con:
# context.build_data_docs()
# context.open_data_docs()
print("\nPara una visualización interactiva de los resultados, Great Expectations genera 'Data Docs' en HTML.")
print("En un entorno configurado, podrías abrirlos para explorar los detalles.")

Con Great Expectations, las “expectativas” se convierten en pruebas programáticas que verifican la salud de mis datos. La salida nos muestra si cada expectativa se cumplió o falló, y nos da detalles sobre por qué. Por ejemplo, si alguna edad estuviera fuera del rango de 0-100, la expectativa `expect_column_values_to_be_between` fallaría y el resultado nos indicaría cuántos valores no cumplieron con esta regla.

Manejo de Datos que No Cumplen las Expectativas

Una vez que identificamos los problemas de calidad, el siguiente paso es decidir cómo manejarlos. Las herramientas de validación nos alertan, pero la solución depende del contexto.

Registrar y Reportar: En muchos casos, especialmente en pipelines de datos, simplemente registrar las fallas y generar un reporte es suficiente para que otro proceso o un analista humano revise los datos y los corrija en la fuente. Great Expectations es excelente para esto con sus Data Docs.
Filtrar o Eliminar: Si la cantidad de datos defectuosos es pequeña y no crítica para el análisis, podríamos optar por filtrar o eliminar los registros que no cumplen las expectativas.
Imputar o Corregir: Para valores nulos o incorrectos, técnicas de imputación (media, mediana, moda, modelos predictivos) o reglas de negocio para corrección pueden ser aplicadas.
Detener el Proceso: Si la calidad de los datos es tan pobre que podría comprometer seriamente los resultados, el framework podría detener el pipeline de datos para evitar que datos erróneos lleguen a producción.

Por ejemplo, si Pandera nos alerta sobre edades negativas, podríamos tener un paso posterior que filtre esos registros o los impute. Si `embarked` tiene nulos, podríamos imputarlos con el puerto más común (‘S’ en el Titanic) antes de pasar los datos a un modelo.

La Importancia de la Calidad de Datos para la Toma de Decisiones

Dimensiones de la Calidad de Datos y Herramientas de Python

Dimensiones Clave de la Calidad de Datos

Completitud (Completeness): ¿Faltan valores en nuestros datos? Un dato es completo si todos los valores esperados están presentes y registrados. Por ejemplo, si un campo como “Edad” tiene muchos valores nulos, su completitud es baja.
Unicidad (Uniqueness): ¿Existen duplicados en nuestros registros? La unicidad asegura que cada entidad se representa una sola vez en el dataset. Los registros duplicados pueden sesgar análisis y modelos.
Validez (Validity): ¿Los datos se ajustan a un formato, tipo o rango predefinido? La validez verifica que los datos cumplan con las reglas de negocio y las restricciones de formato. Por ejemplo, una edad no puede ser negativa o una fecha debe seguir un formato específico.
Consistencia (Consistency): ¿Los datos son coherentes en diferentes fuentes o a lo largo del tiempo? La consistencia se refiere a la uniformidad de los datos. Si un cliente tiene diferentes direcciones en dos tablas relacionadas, hay una inconsistencia.
Precisión (Accuracy): ¿Los datos reflejan la realidad? La precisión mide qué tan correctos o verdaderos son los datos en comparación con la fuente original o la realidad. Un error tipográfico en un nombre o un valor incorrecto en una medida reducen la precisión.
Puntualidad (Timeliness): ¿Los datos están disponibles cuando se necesitan y están actualizados? En muchos escenarios, los datos pierden valor rápidamente si no son actuales. Un informe de ventas de ayer es más puntual que uno de hace un mes.

Herramientas de Python para la Calidad de Datos

Python nos ofrece un ecosistema rico en librerías que facilitan la implementación de cheques de calidad de datos. Aquí les presento dos de mis favoritas, que combinan flexibilidad y potencia:

Great Expectations

Pandera

Implementación Práctica: Mejorando la Calidad del Dataset Titanic

Carga y Exploración Inicial del Dataset

Primero, carguemos el dataset y realicemos una exploración inicial para identificar algunos problemas de calidad.

import seaborn as sns
import pandas as pd

# Cargar el dataset del Titanic
df_titanic = sns.load_dataset('titanic')

# Mostrar las primeras filas
print("Primeras 5 filas del dataset Titanic:")
print(df_titanic.head())

# Obtener información general del DataFrame
print("\nInformación general del dataset:")
print(df_titanic.info())

# Contar valores nulos por columna
print("\nValores nulos por columna:")
print(df_titanic.isnull().sum())

Si observamos la salida de `df_titanic.info()` y `df_titanic.isnull().sum()`, notaremos rápidamente algunos problemas de calidad:

La columna ‘Age’ (Edad) tiene muchos valores nulos (177 de 891 registros). Esto afecta la completitud.
La columna ‘Embarked’ (Puerto de embarque) también tiene algunos valores nulos (2 de 891 registros), aunque menos críticos.
La columna ‘Cabin’ (Cabina) está en una situación mucho peor, con la gran mayoría de sus valores nulos. Su completitud es muy baja.
Podríamos asumir que ‘Sex’ (Género) solo debería tener ‘male’ o ‘female’, y que ‘Survived’ (Sobrevivió) debería ser 0 o 1. Estos son aspectos de validez.
Las edades no deberían ser negativas o excesivamente altas (validez).

Validación de Calidad de Datos con Pandera

import pandera as pa
from pandera import Column, DataFrameSchema, Check

# Definir el esquema de validación para el dataset Titanic
schema_titanic = DataFrameSchema(
    columns={
        "survived": Column(int, Check.isin([0, 1]), nullable=False), # Sobrevivió: 0 o 1, no nulo
        "pclass": Column(int, Check.isin([1, 2, 3]), nullable=False), # Clase: 1, 2 o 3, no nulo
        "sex": Column(str, Check.isin(["male", "female"]), nullable=False), # Sexo: 'male' o 'female', no nulo
        "age": Column(float, Check.in_range(0, 100), nullable=True), # Edad: flotante entre 0 y 100, puede ser nulo
        "sibsp": Column(int, Check.in_range(0, 10), nullable=False), # Hermanos/Cónyuges: entero, no nulo
        "parch": Column(int, Check.in_range(0, 10), nullable=False), # Padres/Hijos: entero, no nulo
        "fare": Column(float, Check.greater_than_or_equal_to(0), nullable=False), # Tarifa: flotante >= 0, no nulo
        "embarked": Column(str, Check.isin(["C", "Q", "S"]), nullable=True), # Puerto de embarque: 'C', 'Q', 'S', puede ser nulo
        "class": Column(str, Check.isin(["First", "Second", "Third"]), nullable=False), # Clase como string, no nulo
        "who": Column(str, Check.isin(["man", "woman", "child"]), nullable=False), # Quién: 'man', 'woman', 'child', no nulo
        "adult_male": Column(bool, nullable=False), # Adulto masculino: booleano, no nulo
        "deck": Column(str, nullable=True), # Cubierta: string, puede ser nulo
        "embark_town": Column(str, Check.isin(["Cherbourg", "Queenstown", "Southampton"]), nullable=True), # Ciudad de embarque: string, puede ser nulo
        "alive": Column(str, Check.isin(["yes", "no"]), nullable=False), # Vivo: 'yes' o 'no', no nulo
        "alone": Column(bool, nullable=False), # Solo: booleano, no nulo
    },
    strict=True # Asegura que no haya columnas extra no definidas en el esquema
)

try:
    # Validar el DataFrame contra el esquema
    schema_titanic.validate(df_titanic, lazy=True)
    print("\n¡El DataFrame cumple con el esquema de Pandera!")
except pa.errors.SchemaErrors as err:
    print("\nErrores de validación de Pandera detectados:")
    print(err.failure_cases) # Mostrar los casos que no cumplen las expectativas
    print(err.data) # Mostrar el DataFrame original para contexto

Validación de Calidad de Datos con Great Expectations

import great_expectations as ge
import great_expectations.jupyter_ux

# Convertir el DataFrame de pandas a un objeto Great Expectations
# Esto permite usar las funciones de expectativa directamente
ge_df_titanic = ge.from_pandas(df_titanic)

# Crear una suite de expectativas
# En un entorno real, esto se haría a través de `great_expectations suite new`
# y luego editando el archivo de la suite. Aquí lo construimos en memoria.
suite = ge_df_titanic.create_expectation_suite(
    "titanic_data_quality_suite"
)

# Añadir expectativas al DataFrame
# Expectativas de Completitud
ge_df_titanic.expect_column_values_to_not_be_null("pclass")
ge_df_titanic.expect_column_values_to_not_be_null("sex")
ge_df_titanic.expect_column_values_to_not_be_null("survived")

# Expectativas de Validez (rangos y valores permitidos)
ge_df_titanic.expect_column_values_to_be_of_type("age", "float")
ge_df_titanic.expect_column_values_to_be_between("age", min_value=0, max_value=100)
ge_df_titanic.expect_column_values_to_be_in_set("sex", ["male", "female"])
ge_df_titanic.expect_column_values_to_be_in_set("embarked", ["C", "Q", "S", None]) # Incluimos None por los nulos
ge_df_titanic.expect_column_values_to_be_between("fare", min_value=0, max_value=520) # Fare tiene un máximo de ~512

# Expectativas de Unicidad (si aplicara a alguna columna, por ejemplo, un ID único)
# ge_df_titanic.expect_column_values_to_be_unique("passenger_id") # No tenemos un ID único en este dataset

# Guardar la suite (en un entorno real, se guardaría en el disco)
ge_df_titanic.save_expectation_suite(discard_failed_expectations=False)

# Ejecutar la validación
results = ge_df_titanic.validate()

# Imprimir un resumen de los resultados
print("\nResultados de la validación con Great Expectations:")
print(f"Éxito general: {results['success']}")
print("Detalle de las expectativas:")
for res in results['results']:
    print(f"- Expectativa: {res['expectation_config']['expectation_type']} "
          f"| Columna: {res['expectation_config']['kwargs'].get('column', 'N/A')} "
          f"| Éxito: {res['success']} "
          f"| Detalles: {res['result']}")

# Si quieres ver los Data Docs (HTML interactivo), en un entorno real lo lanzarías con:
# context.build_data_docs()
# context.open_data_docs()
print("\nPara una visualización interactiva de los resultados, Great Expectations genera 'Data Docs' en HTML.")
print("En un entorno configurado, podrías abrirlos para explorar los detalles.")

Manejo de Datos que No Cumplen las Expectativas

Una vez que identificamos los problemas de calidad, el siguiente paso es decidir cómo manejarlos. Las herramientas de validación nos alertan, pero la solución depende del contexto.

Registrar y Reportar: En muchos casos, especialmente en pipelines de datos, simplemente registrar las fallas y generar un reporte es suficiente para que otro proceso o un analista humano revise los datos y los corrija en la fuente. Great Expectations es excelente para esto con sus Data Docs.
Filtrar o Eliminar: Si la cantidad de datos defectuosos es pequeña y no crítica para el análisis, podríamos optar por filtrar o eliminar los registros que no cumplen las expectativas.
Imputar o Corregir: Para valores nulos o incorrectos, técnicas de imputación (media, mediana, moda, modelos predictivos) o reglas de negocio para corrección pueden ser aplicadas.
Detener el Proceso: Si la calidad de los datos es tan pobre que podría comprometer seriamente los resultados, el framework podría detener el pipeline de datos para evitar que datos erróneos lleguen a producción.

Conclusiones y Mejores Prácticas

A lo largo de este artículo, he querido llevarlos de la mano por el fascinante y crucial mundo de la calidad de datos. Hemos explorado qué es un framework de calidad de datos, las dimensiones clave que lo definen (completitud, unicidad, validez, consistencia, precisión y puntualidad) y cómo herramientas poderosas de Python como Pandera y Great Expectations nos permiten poner estas ideas en práctica. Aplicando estos conceptos a un dataset real como el del Titanic, hemos visto cómo identificar problemas y cómo estas librerías nos asisten en la validación sistemática.

Implementar un framework de calidad de datos no es solo una buena práctica; es una necesidad imperante en cualquier proyecto de ciencia de datos serio. Los beneficios son claros y tangibles:

Mayor Confianza en los Datos: Al saber que nuestros datos han pasado por rigurosos controles, la confianza en los análisis y modelos resultantes se dispara.
Decisiones Más Informadas: Datos de alta calidad conducen a insights más precisos y, por ende, a decisiones de negocio más acertadas y con menor riesgo.
Reducción de Errores y Retrabajos: Identificar y corregir problemas de calidad de datos temprano en el ciclo de vida del proyecto ahorra tiempo y recursos significativos.
Mejora de la Colaboración: Herramientas como Great Expectations, con sus Data Docs, facilitan la comunicación sobre el estado y las expectativas de calidad de los datos entre diferentes equipos.
Automatización y Escalabilidad: La capacidad de definir expectativas como código permite automatizar los controles de calidad, haciendo que el proceso sea escalable y repetible.

Recomendaciones para Mantener la Calidad de los Datos

Empezar Temprano: Integrar los controles de calidad desde las primeras etapas de un proyecto. Es mucho más fácil prevenir problemas que corregirlos a posteriori.
Definir Expectativas Claras: Antes de escribir una línea de código, tómate el tiempo para entender y documentar qué esperas de tus datos. Colabora con los expertos del dominio para asegurar que las reglas de negocio se reflejan en tus expectativas de calidad.
Automatizar Siempre que Sea Posible: Utiliza librerías como Pandera y Great Expectations para automatizar la validación de datos en tus pipelines de ingesta, ETL/ELT y preprocesamiento.
Monitoreo Continuo: La calidad de los datos no es un estado estático. Implementa sistemas de monitoreo para detectar desviaciones o degradaciones de la calidad a lo largo del tiempo y activa alertas cuando se violen las expectativas.
Fomentar una Cultura de Calidad de Datos: La calidad de datos es responsabilidad de todos los que trabajan con ellos. Promueve la concienciación y la capacitación sobre la importancia de datos precisos y fiables.
Documentación Viva: Mantén la documentación de tus reglas de calidad de datos actualizada. Great Expectations hace un trabajo fantástico en esto con sus Data Docs, que se actualizan con cada ejecución de validación.

La calidad de los datos es la columna vertebral de cualquier iniciativa impulsada por datos. Al invertir tiempo y esfuerzo en construir y mantener un robusto framework de calidad de datos, no solo garantizamos la fiabilidad de nuestros resultados, sino que también sentamos las bases para una innovación y un éxito continuos en el apasionante campo de la ciencia de datos.

Recuerda que siempre siempre vas a aprender un bit a la vez!

Promoción

¿Quieres profundizar aún más en el mundo de la ciencia de datos y dominar las herramientas y técnicas que te llevarán al siguiente nivel? Te invito a explorar mi curso completo de Ciencia de Datos con Python y R, donde aprenderás desde los fundamentos hasta la implementación de proyectos complejos. ¡No dejes pasar la oportunidad de transformar tu carrera!

Inscríbete aquí: Ciencia de Datos con Python y R