Gran tutorial de Expectativas: Validación de datos con Python

Tutoriales
Python

La calidad de los datos y la consistencia son como los cimientos de una casa: sin una base sólida, todo lo construido encima corre el riesgo de colapsar. Aquí es donde la validación de datos juega un papel importante. La validación de datos te ayuda a asegurarte de que tus datos sean precisos, consistentes y confiables.

Great Expectations es una herramienta de validación de datos de código abierto que te permite identificar problemas de datos a tiempo y garantiza que tus datos cumplan con los estándares de calidad requeridos.

En esta guía, te guiaremos a través del proceso de usar Great Expectations para la validación de datos, con un ejemplo práctico de principio a fin para ayudarte a comenzar.

¿Qué es Great Expectations?

Great Expectations (GX) es un marco de código abierto que se ha vuelto popular para gestionar y automatizar la validación de datos en pipelines de datos modernos.

Su marco basado en Python está diseñado para ayudar a los equipos de datos a garantizar la calidad y consistencia de sus datos. Los usuarios pueden definir “expectativas” – reglas o pruebas que describen cómo deberían ser los datos válidos – que validan automáticamente si los datos cumplen con estos estándares.

Algunos beneficios de Great Expectations incluyen:

  • Validación automática de datos – Great Expectations automatiza el proceso de validación de datos, reduciendo el esfuerzo manual y minimizando el riesgo de errores. Garantiza que los datos cumplan consistentemente con los estándares predefinidos.
  • Integración con tuberías de datos – Se integra fácilmente con diversas fuentes de datos y plataformas, incluidas bases de datos SQL, almacenamiento en la nube, y herramientas ETL, lo que permite la validación de datos en diferentes etapas de su tubería.
  • Resultados de validación claros y accionables – La herramienta proporciona resultados de validación transparentes, lo que facilita la detección rápida de problemas de calidad de datos y su pronta solución.
  • Documentación de datos – Great Expectations puede generar documentación detallada y accesible de sus procesos de validación de datos, ayudando a los equipos a alinearse en los estándares de calidad y proporcionando una referencia para uso futuro.
  • Escalabilidad y flexibilidad – Como una herramienta de código abierto, Great Expectations es altamente personalizable y puede adaptarse a sus necesidades de validación de datos, ofreciendo flexibilidad para ajustarse a varios casos de uso sin costos elevados.

¡Ahora, veamos un ejemplo de principio a fin!

Configuración de Great Expectations

En este tutorial, aprenderás cómo utilizar GX Core, la versión de código abierto de Great Expectations, para validar un DataFrame de Pandas. Te guiaremos a través de la configuración de un contexto, el registro de una fuente de datos de Pandas, la definición de expectativas y la validación de lotes de datos.

Nota: Te recomendamos que sigas el cuaderno DataLab, pero también puedes crear tu propio script en Python.

Prerrequisitos

  • Python 3.9 a 3.12 instalado.
  • Para evitar conflictos, se recomienda encarecidamente instalar Great Expectations dentro de un entorno virtual (descargo de responsabilidad: la configuración de entornos virtuales está más allá del alcance de este artículo).
  • Un conjunto de datos de muestra.

Nota: Si está utilizando el cuaderno DataLab proporcionado, estos requisitos ya se han cumplido. Siéntase libre de omitirlos.

Utiliza el siguiente comando para instalar GX a través de pip:

pip install great_expectations

Este comando instala el paquete principal y todas las dependencias necesarias.

Great Expectations requiere un contexto de datos para gestionar configuraciones. Utilizamos un contexto de datos efímero para evitar persistir configuraciones.

import great_expectations as gx

# Obtener el Contexto de Datos Efímero
context = gx.get_context()
assert type(context).__name__ == "EphemeralDataContext"

Creando tu Primer Conjunto de Validación de Datos

Ahora que GX está configurado, creemos un conjunto de validación de datos.

Una fuente de datos conecta Great Expectations a tus datos, mientras que un activo de datos representa un subconjunto específico de datos (por ejemplo, una tabla, DataFrame o archivo).

En este caso, prepararemos todo para conectarnos a un DataFrame llamado inventory_parts_df. El conjunto de datos de muestra está disponible en el DataLab proporcionado, y se crea una vez que ejecutamos el bloque SQL:

Si no estás utilizando DataLab, crea tu propio DataFrame con datos de muestra.

Ahora, crea tu fuente de datos y activo:

# Agregar una Fuente de Datos de Pandas
data_source = context.data_sources.add_pandas(name="inventory_parts")
# Agregar un Activo de Datos a la Fuente de Datos
data_asset = data_source.add_dataframe_asset(name="inventory_parts_asset")

Una definición de lote identifica y organiza tus datos para validación. Aquí, agregamos una definición de lote que abarca todo el DataFrame:

# Define el nombre de la definición de lote
batch_definition_name = "inventory_parts_batch"
# Agregar la definición de lote
batch_definition = data_asset.add_batch_definition_whole_dataframe(batch_definition_name)
assert batch_definition.name == batch_definition_name

Un lote es una colección de datos vinculada a una definición de lote. Para validar datos, necesitarás recuperar y vincular el lote a tu DataFrame, en este caso inventory_parts_df:

# Definir los parámetros del lote
batch_parameters = {"dataframe": inventory_parts_df}
# Recuperar el lote
batch = batch_definition.get_batch(batch_parameters=batch_parameters)

Las expectativas son reglas para validar datos. En este ejemplo, definiremos las siguientes expectativas simples:

  1. Asegurar que los valores de inventory_id no sean nulos.
  2. Asegurar que los valores de part_num sean únicos.
# Crear una Suite de Expectativas
expectation_suite_name = "inventory_parts_suite"
suite = gx.ExpectationSuite(name=expectation_suite_name)
# Agregar Expectativas
suite.add_expectation(
    gx.expectations.ExpectColumnValuesToNotBeNull(column="inventory_id")
)
suite.add_expectation(
    gx.expectations.ExpectColumnValuesToBeUnique(column="part_num")
)
# Agregar la Suite de Expectativas al Contexto
context.suites.add(suite)

Puedes explorar todas las expectativas disponibles en la Galería de Expectativas. ¡Te animamos a agregar algunas más!

Después de definir las expectativas, GX genera la configuración de la suite de expectativas:

{
  "name": "inventory_parts_suite",
  "id": "b2de0b69-0869-4163-8dde-6c09884483f7",
  "expectations": [
    {
      "type": "expect_column_values_to_not_be_null",
      "kwargs": {
        "column": "inventory_id"
      },
      "meta": {},
      "id": "53d6c42a-d190-412f-a113-783b706531f4"
    },
    {
      "type": "expect_column_values_to_be_unique",
      "kwargs": {
        "column": "part_num"
      },
      "meta": {},
      "id": "362a2bdc-616d-4b3a-b7f0-c73808caee78"
    }
  ],
  "meta": {
    "great_expectations_version": "1.2.4"
  },
  "notes": null
}

La suite incluye los siguientes detalles:

  1. Nombre y ID de la suite: Un nombre único (inventory_parts_suite) e identificador para rastrear y gestionar la suite.
  2. Expectativas: Cada regla especifica:
    • El tipo de verificación (por ejemplo, asegurar que una columna no tenga valores nulos o entradas únicas).
    • Parámetros, como la columna que se está validando.
    • Metadatos y un ID único para cada expectativa, lo que permite un seguimiento y personalización más fáciles.
  3. Metadatos: Información de la versión de Great Expectations, asegurando compatibilidad con la herramienta.
  4. Notas: Un marcador de posición para agregar comentarios descriptivos sobre la suite (opcional).

Esta salida estructurada actúa tanto como documentación como una configuración reutilizable para validar su conjunto de datos, de modo que sus expectativas estén claramente definidas, sean rastreables y estén listas para su uso futuro.

5. Validación de los datos

Finalmente, valide el lote de acuerdo con las expectativas definidas y evalúe los resultados.

# Validar los datos según la suite
validation_results = batch.validate(suite)
# Evaluar los resultados
print(validation_results)

Después de ejecutar la validación, Great Expectations proporciona un informe detallado sobre si el conjunto de datos cumple con las expectativas definidas:

{
  "success": false,
  "results": [
    {
      "success": true,
      "expectation_config": {
        "type": "expect_column_values_to_not_be_null",
        "kwargs": {
          "batch_id": "inventory_parts-inventory_parts_asset",
          "column": "inventory_id"
        },
        "meta": {},
        "id": "53d6c42a-d190-412f-a113-783b706531f4"
      },
      "result": {
        "element_count": 580069,
        "unexpected_count": 0,
        "unexpected_percent": 0.0,
        "partial_unexpected_list": [],
        "partial_unexpected_counts": [],
        "partial_unexpected_index_list": []
      },
      "meta": {},
      "exception_info": {
        "raised_exception": false,
        "exception_traceback": null,
        "exception_message": null
      }
    },
    {
      "success": false,
      "expectation_config": {
        "type": "expect_column_values_to_be_unique",
        "kwargs": {
          "batch_id": "inventory_parts-inventory_parts_asset",
          "column": "part_num"
        },
        "meta": {},
        "id": "362a2bdc-616d-4b3a-b7f0-c73808caee78"
      },
      "result": {
        "element_count": 580069,
        "unexpected_count": 568352,
        "unexpected_percent": 97.98006788847535,
        "partial_unexpected_list": [
          "48379c01",
          "paddle",
          "11816pr0005",
          "2343",
          "3003",
          "30176",
          "3020",
          "3022",
          "3023",
          "30357",
          "3039",
          "3062b",
          "3068b",
          "3069b",
          "3069b",
          "33291",
          "33291",
          "3795",
          "3941",
          "3960"
        ],
        "missing_count": 0,
        "missing_percent": 0.0,
        "unexpected_percent_total": 97.98006788847535,
        "unexpected_percent_nonmissing": 97.98006788847535,
        "partial_unexpected_counts": [
          {
            "value": "3069b",
            "count": 2
          },
          {
            "value": "33291",
            "count": 2
          },
          {
            "value": "11816pr0005",
            "count": 1
          },
          {
            "value": "2343",
            "count": 1
          },
          {
            "value": "3003",
            "count": 1
          },
          {
            "value": "30176",
            "count": 1
          },
          {
            "value": "3020",
            "count": 1
          },
          {
            "value": "3022",
            "count": 1
          },
          {
            "value": "3023",
            "count": 1
          },
          {
            "value": "30357",
            "count": 1
          },
          {
            "value": "3039",
            "count": 1
          },
          {
            "value": "3062b",
            "count": 1
          },
          {
            "value": "3068b",
            "count": 1
          },
          {
            "value": "3795",
            "count": 1
          },
          {
            "value": "3941",
            "count": 1
          },
          {
            "value": "3960",
            "count": 1
          },
          {
            "value": "48379c01",
            "count": 1
          },
          {
            "value": "paddle",
            "count": 1
          }
        ],
        "partial_unexpected_index_list": [
          0,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21
        ]
      },
      "meta": {},
      "exception_info": {
        "raised_exception": false,
        "exception_traceback": null,
        "exception_message": null
      }
    }
  ],
  "suite_name": "inventory_parts_suite",
  "suite_parameters": {},
  "statistics": {
    "evaluated_expectations": 2,
    "successful_expectations": 1,
    "unsuccessful_expectations": 1,
    "success_percent": 50.0
  },
  "meta": {
    "great_expectations_version": "1.2.4",
    "batch_spec": {
      "batch_data": "PandasDataFrame"
    },
    "batch_markers": {
      "ge_load_time": "20241129T122532.416424Z",
      "pandas_data_fingerprint": "84a1e1939091fcf54324910def3b89cd"
    },
    "active_batch_definition": {
      "datasource_name": "inventory_parts",
      "data_connector_name": "fluent",
      "data_asset_name": "inventory_parts_asset",
      "batch_identifiers": {
        "dataframe": "<DATAFRAME>"
      }
    }
  },
  "id": null
}

Este informe detalla la calidad de sus datos, destacando los éxitos y fracasos. Aquí tienes una explicación simplificada de los resultados:

Validación general: El resultado de la validación fue parcialmente exitoso: el 50% de las expectativas se cumplieron y el 50% fallaron. Una expectativa fallida indica un problema de calidad de datos que necesita atención. En este caso, una columna no cumplió con la regla definida.

Expectativa 1: inventory_id no debería tener valores faltantes

  • Resultado: Aprobado
  • Explicación: Cada valor en la columna inventory_id está presente, sin entradas nulas o faltantes. Esto indica una buena completitud de datos para esta columna.

Expectativa 2: part_num debería tener valores únicos

  • Resultado: Falló
  • Explicación: La columna part_num contiene un 97,98% de valores duplicados, lo que significa que solo unos pocos valores son únicos.
  • Aspectos destacados:
    • Ejemplos de valores duplicados incluyen “3069b” y “33291”.
    • La herramienta también muestra con qué frecuencia aparecen estos duplicados y sus posiciones de fila, lo que facilita la ubicación y corrección de los problemas.

Por supuesto, este es solo un conjunto de datos de muestra, e incluimos intencionalmente una expectativa que pasa y otra que falla para que puedas ver ambos resultados de validación.

¡Eso es todo! Has ejecutado con éxito validaciones de extremo a extremo de datos.

Integración de Great Expectations en Tuberías de Datos

En un entorno de producción, las validaciones deben integrarse directamente en el flujo de trabajo para monitorear continuamente la calidad de los datos en cada etapa.

En esta sección, discutiremos cómo puedes integrar Great Expectations en tus tuberías de datos.

Estos son ejemplos para darte una idea, y pueden requerirse configuraciones adicionales que no se incluyen aquí. ¡Consulta la documentación de cada herramienta para obtener la sintaxis actualizada!

Integración con herramientas ETL

Integrar Great Expectations con herramientas ETL populares como Apache Airflow o Prefect es relativamente sencillo. Incluir pasos de validación directamente en los procesos ETL te permitirá detectar y abordar problemas de datos en tiempo real antes de que afecten el análisis posterior.

Vamos a recorrer un ejemplo simple de integración de Great Expectations con Prefect para ejecutar la validación de datos como parte de un flujo de trabajo ETL automatizado:

from prefect import task, Flow
import great_expectations as ge
# Define una tarea para ejecutar la validación de Great Expectations
@task
def validate_data():
    context = ge.data_context.DataContext()
    batch_kwargs = {"path": "path/to/your/datafile.csv", "datasource": "your_datasource"}
    batch = context.get_batch(batch_kwargs, suite_name="your_expectation_suite")
    results = context.run_validation_operator("action_list_operator", assets_to_validate=[batch])
	    
    # Verifica los resultados de la validación y genera una alerta si la validación falla
    if not results["success"]:
        raise ValueError("Data validation failed!")
# Define tu flujo ETL
with Flow("ETL_with_GE_Validation") as flow:
    validation = validate_data()
# Ejecuta el flujo
flow.run()

En este ejemplo, definimos un flujo de Prefect con una tarea para ejecutar la validación de Great Expectations.

La tarea validate_data() carga el contexto de Great Expectations, recupera el lote de datos y aplica la suite de expectativas.

Si los datos no cumplen con los criterios de validación, la tarea genera una alerta, deteniendo el flujo de trabajo y evitando errores posteriores.

Validación continua de datos

Puedes programar trabajos de validación utilizando varias herramientas, como trabajos cron en sistemas basados en Unix o servicios gestionados como Apache Airflow. Para este ejemplo, demostraremos cómo programar ejecuciones de validación usando Airflow, que es muy adecuado para orquestar flujos de datos.

A continuación, te mostramos cómo puedes configurar un DAG de Airflow (Grafo Acíclico Dirigido) para ejecutar validaciones de Great Expectations a diario:

from airflow import DAG
from airflow.operators.python_operator import PythonOperator
from datetime import datetime
import great_expectations as ge
Define el DAG y establece la programación para que se ejecute diariamente
default_args = {
	  'owner': 'airflow',
	  'start_date': datetime(2024, 1, 1),
	  'retries': 1,
}
dag = DAG(
      'great_expectations_validation',
	default_args=default_args,
	schedule_interval='@daily',  Ejecuta una vez al día
)
Define la función para ejecutar la validación
def run_validation():
    context = ge.data_context.DataContext()
    batch = context.get_batch(batch_kwargs, suite_name="your_expectation_suite")
    results = context.run_validation_operator("action_list_operator", assets_to_validate=[batch])
    return results
Configura la tarea en Airflow
validation_task = PythonOperator(
      task_id='run_great_expectations_validation',
      python_callable=run_validation,
      dag=dag,
)
Establece la tarea en el DAG
validation_task

En este ejemplo, definimos un DAG que programa una ejecución de validación una vez al día (@daily).

La función run_validation() ejecuta la validación cargando el contexto de Great Expectations y ejecutando el conjunto de expectativas definido contra los datos.

Mejores Prácticas para la Validación de Datos con Great Expectations

Seguir las mejores prácticas siempre es lo más recomendado para la escalabilidad y eficiencia, y no es diferente para la validación de datos con Great Expectations.

Comienza pequeño e itera

Comience con comprobaciones básicas de calidad de datos y expanda gradualmente. Es mejor enfocarse en las expectativas básicas inicialmente, ya que esto ayuda a evitar complicar en exceso el proceso, lo que facilita una integración más fluida y una solución de problemas más sencilla. A medida que su comprensión del conjunto de datos mejora, puede agregar validaciones más complejas.

Colaborar entre equipos

La calidad de datos no es solo una preocupación técnica. Colabore entre equipos comerciales para definir expectativas y asegurarse de que la validación implementada se alinee con la lógica empresarial subyacente y los objetivos. Este enfoque interfuncional garantiza que los datos sirvan a su propósito previsto y cumplan con los requisitos de todas las partes interesadas.

Automatizar cuando sea posible

Automatice el proceso siempre que sea posible para integrar la validación de datos en los flujos de datos. La integración de comprobaciones automatizadas de validación permite la monitorización continua de la calidad de los datos sin intervención manual, lo que mejora significativamente la eficiencia.

Conclusión

¡Excelente trabajo! Has aprendido cómo configurar y validar datos en Great Expectations. Estas técnicas te ayudarán a mantener una alta calidad de datos y transparencia en tus flujos de trabajo.

Para seguir desarrollando tus habilidades, consulta estos recursos:

Source:
https://www.datacamp.com/tutorial/great-expectations-tutorial