Tutorial de Grandes esperanzas: Validar datos con Python

Crear grandes expectativas

En este tutorial, aprenderás a utilizar GX Core, la versión de código abierto de Grandes Expectativas, para validar un DataFrame de Pandas. Pasaremos por la configuración de un contexto, el registro de una fuente de datos 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.

1. Instalación de Grandes Expectativas

Requisitos previos

• Python 3.9 a 3.12 instalado.
• Para evitar conflictos, se recomienda encarecidamente que instales Grandes esperanzas en un entorno virtual (descargo de responsabilidad: la instalación de entornos virtuales está fuera del alcance de este artículo).
• Un conjunto de datos de muestra.

Nota: Si utilizas el cuaderno DataLab proporcionado, estos requisitos previos ya se habrán cumplido. Siéntete libre de saltártelos.

Utiliza el siguiente comando para instalar GX mediante pip:

pip install great_expectations

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

2. Inicializar el contexto de datos

Grandes Expectativas requiere un contexto de datos para gestionar las configuraciones. Utilizamos un contexto de datos efímero para evitar la persistencia de las configuraciones.

import great_expectations as gx

# Get the Ephemeral Data Context
context = gx.get_context()
assert type(context).__name__ == "EphemeralDataContext"

Crear tu primer paquete de validación de datos

Ahora que GX está configurado, vamos a crear un conjunto de validación de datos.

1. Conectarse a una fuente de datos y crear un activo 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, un DataFrame o un 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 utilizas DataLab, crea tu propio DataFrame con datos de ejemplo.

Ahora, crea tu fuente de datos y tu activo:

# Add a Pandas Data Source
data_source = context.data_sources.add_pandas(name="inventory_parts")
# Add a Data Asset to the Data Source
data_asset = data_source.add_dataframe_asset(name="inventory_parts_asset")

2. Añadir una definición de lote

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

# Define the Batch Definition name
batch_definition_name = "inventory_parts_batch"
# Add the Batch Definition
batch_definition = data_asset.add_batch_definition_whole_dataframe(batch_definition_name)
assert batch_definition.name == batch_definition_name

3. Recuperar un lote

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

# Define the Batch Parameters
batch_parameters = {"dataframe": inventory_parts_df}
# Retrieve the Batch
batch = batch_definition.get_batch(batch_parameters=batch_parameters)

4. Crear una suite y definir las expectativas

Las expectativas son normas para validar los datos. En este ejemplo, definiremos las siguientes expectativas sencillas:

1. Asegúrate de que los valores de inventory_id no sean nulos.
2. Asegúrate de que los valores de part_num son únicos.

# Create an Expectation Suite
expectation_suite_name = "inventory_parts_suite"
suite = gx.ExpectationSuite(name=expectation_suite_name)
# Add Expectations
suite.add_expectation(
    gx.expectations.ExpectColumnValuesToNotBeNull(column="inventory_id")
)
suite.add_expectation(
    gx.expectations.ExpectColumnValuesToBeUnique(column="part_num")
)
# Add the Expectation Suite to the Context
context.suites.add(suite)

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

Tras definir las expectativas, GX da salida a la configuración del conjunto 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 e ID de la suite: Un nombre único (inventory_parts_suite) y un identificador para rastrear y gestionar la suite.
2. Expectativas: Cada regla especifica:
• El tipo de comprobación (por ejemplo, asegurarse de que una columna no tiene 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 una personalización más sencillos.
3. Metadata: Información sobre la versión de Grandes esperanzas, que garantiza la compatibilidad con la herramienta.
4. Notas: Un marcador de posición para añadir comentarios descriptivos sobre el conjunto (opcional).

Este resultado estructurado actúa como documentación y como configuración reutilizable para validar tu conjunto de datos, de modo que tus expectativas estén claramente definidas, sean trazables y estén listas para su uso futuro.

5. Validar los datos

Por último, valida el lote frente a las expectativas definidas y evalúa los resultados.

# Validate the Data Against the Suite
validation_results = batch.validate(suite)
# Evaluate the Results
print(validation_results)

Tras ejecutar la validación, Grandes Expectativas proporciona un informe detallado sobre si el conjunto de datos cumple 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 tus datos, destacando los éxitos y los fracasos. He aquí una explicación simplificada de los resultados:

Validación global: El resultado de la validación fue parcialmente satisfactorio: El 50% de las expectativas se superaron y el otro 50% fracasaron. Una expectativa fallida indica un problema de calidad de los datos que requiere atención. En este caso, una columna no cumplía la regla definida.

Expectativa 1: inventory_id no deben faltar valores

• Resultado: Aprobado
• Explicación: Todos los valores de la columna inventory_id están presentes, sin entradas nulas o ausentes. Esto indica una buena integridad de los datos de esta columna.

Expectativa 2: part_num deben tener valores únicos

• Resultado: Fallido
• Explicación: La columna part_num contiene un 97,98% de valores duplicados, lo que significa que sólo unos pocos valores son únicos.
• Lo más destacado:
• Algunos ejemplos de valores duplicados son "3069b" y "33291".
• La herramienta también muestra la frecuencia con que aparecen estos duplicados y sus posiciones en las filas, lo que facilita la localización y solución de los problemas.

Por supuesto, se trata sólo de un conjunto de datos de muestra, y hemos incluido a propósito una expectativa de aprobado y otra de suspenso para que puedas ver los resultados de ambas validaciones.

Eso es. Has realizado con éxito validaciones de datos de extremo a extremo.

Integrar las Grandes Expectativas en las Cadenas de Datos

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

En esta sección, hablaremos de cómo puedes integrar Grandes Expectativas en tus canalizaciones de datos.

Estos son ejemplos para que te hagas una idea, y pueden ser necesarias configuraciones adicionales no incluidas aquí. Consulta la documentación de cada herramienta para conocer la sintaxis actualizada.

Integración con herramientas ETL

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

Veamos un ejemplo sencillo 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 a task to run Great Expectations validation
@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])
	    
    # Check validation results and raise an alert if validation fails
    if not results["success"]:
        raise ValueError("Data validation failed!")
# Define your ETL flow
with Flow("ETL_with_GE_Validation") as flow:
    validation = validate_data()
# Execute the flow
flow.run()

En este ejemplo, definimos un flujo Prefecto con una tarea para ejecutar la validación de Grandes esperanzas.

La tarea validate_data() carga el contexto Grandes Expectativas, recupera el lote de datos y aplica el conjunto de expectativas. 

Si los datos no cumplen los criterios de validación, la tarea emite 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. En este ejemplo, mostraremos cómo programar ejecuciones de validación utilizando Airflow, que es muy adecuado para orquestar canalizaciones de datos.

A continuación te explicamos cómo puedes configurar un Airflow DAG(grafo acíclico dirigido) para ejecutar diariamente las validaciones de Grandes Expectativas:

from airflow import DAG
from airflow.operators.python_operator import PythonOperator
from datetime import datetime
import great_expectations as ge
# Define the DAG and set the schedule to run daily
default_args = {
	  'owner': 'airflow',
	  'start_date': datetime(2024, 1, 1),
	  'retries': 1,
}
dag = DAG(
      'great_expectations_validation',
	default_args=default_args,
	schedule_interval='@daily',  # Runs once a day
)
# Define the function to run the validation
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
# Set up the task in Airflow
validation_task = PythonOperator(
      task_id='run_great_expectations_validation',
      python_callable=run_validation,
      dag=dag,
)
# Set the task in the 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 Grandes Expectativas y ejecutando el conjunto de expectativas definido con los datos.

Buenas prácticas para la validación de datos con grandes expectativas

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

Empieza poco a poco e itera

Empieza con comprobaciones básicas de la calidad de los datos y amplíalas gradualmente. Es mejor centrarse inicialmente en las expectativas básicas, ya que así se evita complicar demasiado el proceso, lo que facilita la integración y la resolución de problemas. A medida que mejore tu comprensión del conjunto de datos, podrás añadir validaciones más complejas.

Colaborar entre equipos

La calidad de los datos no es sólo una cuestión técnica. Colabora con todos los equipos empresariales para definir las expectativas y garantizar que la validación implementada se alinea con la lógica y los objetivos empresariales subyacentes. Este enfoque interfuncional garantiza que los datos sirvan para el fin previsto y satisfagan los requisitos de todas las partes interesadas.

Automatiza cuando sea posible

Automatiza el proceso siempre que sea factible para integrar la validación de datos en los pipelines de datos. La integración de comprobaciones de validación automatizadas permite una supervisión continua de la calidad de los datos sin intervención manual, lo que mejora notablemente la eficacia.

Conclusión

¡Gran trabajo! Has aprendido a configurar y validar datos en Grandes Expectativas. 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:

• ETL y ELT en Python: Aprende a transformar y mover datos con eficacia.
• Introducción a la Calidad de los Datos: Explora los fundamentos de la gestión de la calidad de los datos.
• Limpieza de datos en Python: Técnicas de limpieza de datos maestros para garantizar la precisión y la coherencia.
• Ficha sobre las Dimensiones de la Calidad de los Datos: Una guía práctica sobre las dimensiones de la calidad de los datos.