Cómo probar sus datos con grandes expectativas

El autor seleccionó el Fondo de Diversidad en Tecnología para recibir una donación como parte del programa Write for DOnations .

Introducción

En este tutorial, configurará una implementación local de Great Expectations , una biblioteca de documentación y validación de datos de código abierto escrita en Python. La validación de datos es fundamental para garantizar que los datos que procesa en sus canalizaciones sean correctos y estén libres de problemas de calidad de datos que puedan ocurrir debido a errores como entradas incorrectas o errores de transformación. Great Expectations le permite establecer afirmaciones sobre sus datos llamadas Expectations y validar cualquier dato utilizando esas Expectations.

Cuando haya terminado, podrá conectar Great Expectations a sus datos, crear un conjunto de Expectations, validar un lote de datos utilizando esas Expectations y generar un informe de calidad de datos con los resultados de su validación.

Prerrequisitos

Para completar este tutorial, necesitarás:

• Un entorno de desarrollo local para Python 3.6 o superior. Puedes seguir el tutorial correspondiente a tu sistema operativo en esta serie: Cómo instalar y configurar un entorno de programación local para Python 3. Se recomienda utilizar un entorno de programación local para evitar problemas de conexión al navegador.
• Conocimientos básicos de Python. Puedes consultar el libro electrónico Cómo codificar en Python para obtener más información.
• Alguna familiaridad con los cuadernos Jupyter .
• Una instalación funcional de Git .
• Un navegador web como Firefox o Chrome .

Paso 1: Instalación de Great Expectations e inicialización de un proyecto de Great Expectations

En este paso, instalará el paquete Great Expectations en su entorno Python local, descargará los datos de muestra que usará en este tutorial e inicializará un proyecto Great Expectations.

Para comenzar, abra una terminal y asegúrese de activar su entorno virtual de Python. Instale el paquete Python de Great Expectations y la herramienta de línea de comandos (CLI) con el siguiente comando:

pip install great_expectations==0.13.35

Nota : Este tutorial fue desarrollado para la versión 0.13.35 de Great Expectations y puede no ser aplicable a otras versiones.

Para tener acceso al repositorio de datos de ejemplo, ejecute el siguiente comando git para clonar el directorio y convertirlo en su directorio de trabajo:

git clone https://github.com/do-community/great_expectations_tutorial
cd great_expectations_tutorial

El repositorio solo contiene una carpeta llamada data, que contiene dos archivos CSV de ejemplo con datos que utilizará en este tutorial. Eche un vistazo al contenido del datadirectorio:

ls data

Verás el siguiente resultado:

Outputyellow_tripdata_sample_2019-01.csvyellow_tripdata_sample_2019-02.csv

Great Expectations trabaja con muchos tipos de datos diferentes, como conexiones a bases de datos relacionales, marcos de datos de Spark y varios formatos de archivo. Para este tutorial, utilizará estos archivos CSV que contienen un pequeño conjunto de datos de viajes en taxi para comenzar.

Por último, inicialice su directorio como un proyecto de Great Expectations ejecutando el siguiente comando. Asegúrese de utilizar el --v3-apiindicador, ya que esto le permitirá utilizar la API más reciente del paquete:

great_expectations --v3-api init

Cuando se le solicite OK to proceed? [Y/n]:, presione ENTERpara continuar.

Esto creará una carpeta llamada great_expectations, que contiene la configuración básica para su proyecto Great Expectations, también llamada Contexto de datos . Puede inspeccionar el contenido de la carpeta:

ls great_expectations

Verás el primer nivel de archivos y subdirectorios que se crearon dentro de la great_expectationscarpeta:

Outputcheckpointsgreat_expectations.ymlpluginsexpectationsnotebooksuncommitted

Las carpetas almacenan todo el contenido relevante para la configuración de Great Expectations. El great_expectations.ymlarchivo contiene toda la información de configuración importante. No dude en explorar las carpetas y el archivo de configuración un poco más antes de continuar con el siguiente paso del tutorial.

En el siguiente paso, agregará una fuente de datos para apuntar a Great Expectations hacia sus datos.

Paso 2: Agregar una fuente de datos

En este paso, configurará una fuente de datos en Great Expectations, que le permitirá crear automáticamente afirmaciones de datos llamadas Expectativas , así como validar datos con la herramienta.

Mientras esté en el directorio de su proyecto, ejecute el siguiente comando:

great_expectations --v3-api datasource new

Verá el siguiente resultado. Ingrese las opciones que se muestran cuando se le solicite que configure una fuente de datos basada en archivos para el datadirectorio:

OutputWhat data would you like Great Expectations to connect to?    1. Files on a filesystem (for processing with Pandas or Spark)    2. Relational database (SQL): 1What are you processing your files with?    1. Pandas    2. PySpark: 1Enter the path of the root directory where the data files are stored. If files are on local disk enter a path relative to your current working directory or an absolute path.: data

Después de confirmar la ruta del directorio con ENTER, Great Expectations abrirá un cuaderno Jupyter en su navegador web, que le permitirá completar la configuración de la fuente de datos y almacenarla en su contexto de datos. La siguiente captura de pantalla muestra las primeras celdas del cuaderno:

El cuaderno contiene varias celdas precargadas de código Python para configurar su fuente de datos. Puede modificar la configuración de la fuente de datos, como el nombre, si lo desea. Sin embargo, para los fines de este tutorial, dejará todo como está y ejecutará todas las celdas utilizando la Cell Run Allopción de menú. Si se ejecuta correctamente, la salida de la última celda se verá de la siguiente manera:

Output[{'data_connectors': {'default_inferred_data_connector_name': {'module_name': 'great_expectations.datasource.data_connector',    'base_directory': '../data',    'class_name': 'InferredAssetFilesystemDataConnector',    'default_regex': {'group_names': ['data_asset_name'], 'pattern': '(.*)'}},   'default_runtime_data_connector_name': {'module_name': 'great_expectations.datasource.data_connector',    'class_name': 'RuntimeDataConnector',    'batch_identifiers': ['default_identifier_name']}},  'module_name': 'great_expectations.datasource',  'class_name': 'Datasource',  'execution_engine': {'module_name': 'great_expectations.execution_engine',   'class_name': 'PandasExecutionEngine'},  'name': 'my_datasource'}]

Esto demuestra que ha agregado una nueva fuente de datos my_datasourcea su contexto de datos. No dude en leer las instrucciones en el cuaderno para obtener más información sobre las diferentes opciones de configuración antes de continuar con el siguiente paso.

Advertencia: antes de continuar, cierre la pestaña del navegador con el notebook, regrese a su terminal y presione CTRL+Cpara apagar el servidor del notebook en ejecución antes de continuar.

Ahora ha configurado correctamente una fuente de datos que apunta al datadirectorio, lo que le permitirá acceder a los archivos CSV del directorio a través de Great Expectations. En el siguiente paso, utilizará uno de estos archivos CSV en su fuente de datos para generar automáticamente Expectations con un generador de perfiles.

Paso 3: Creación de un conjunto de expectativas con un generador de perfiles automatizado

En este paso del tutorial, utilizará el generador de perfiles integrado para crear un conjunto de expectativas en función de algunos datos existentes. Para ello, echemos un vistazo más de cerca a los datos de muestra que ha descargado:

• Los archivos yellow_tripdata_sample_2019-01.csvcontienen yellow_tripdata_sample_2019-02.csvdatos de viajes en taxi de enero y febrero de 2019, respectivamente.
• Este tutorial asume que usted sabe que los datos de enero son correctos y que desea asegurarse de que todos los archivos de datos posteriores coincidan con los datos de enero en términos de número de filas, columnas y distribuciones de ciertos valores de columna.

Para ello, creará expectativas (afirmaciones de datos) basadas en determinadas propiedades de los datos de enero y, luego, en un paso posterior, utilizará esas expectativas para validar los datos de febrero. Comencemos creando un conjunto de expectativas, que es un conjunto de expectativas agrupadas:

great_expectations --v3-api suite new

Al seleccionar las opciones que se muestran en el resultado a continuación, especifica que desea utilizar un generador de perfiles para generar expectativas automáticamente, utilizando el yellow_tripdata_sample_2019-01.csvarchivo de datos como entrada. Ingrese el nombre my_suitecomo el nombre de Expectation Suite cuando se le solicite y presione ENTERal final cuando se le solicite Would you like to proceed? [Y/n]:

OutputUsing v3 (Batch Request) APIHow would you like to create your Expectation Suite?    1. Manually, without interacting with a sample batch of data (default)    2. Interactively, with a sample batch of data    3. Automatically, using a profiler: 3A batch of data is required to edit the suite - let's help you to specify it.Which data asset (accessible by data connector "my_datasource_example_data_connector") would you like to use?    1. yellow_tripdata_sample_2019-01.csv    2. yellow_tripdata_sample_2019-02.csv: 1Name the new Expectation Suite [yellow_tripdata_sample_2019-01.csv.warning]: my_suiteWhen you run this notebook, Great Expectations will store these expectations in a new Expectation Suite "my_suite" here:  path_to_project/great_expectations_tutorial/great_expectations/expectations/my_suite.jsonWould you like to proceed? [Y/n]: press ENTER

Esto abrirá otro cuaderno de Jupyter que le permitirá completar la configuración de Expectation Suite. El cuaderno contiene una buena cantidad de código para configurar el generador de perfiles integrado, que analiza el archivo CSV que seleccionó y crea ciertos tipos de Expectations para cada columna del archivo en función de lo que encuentre en los datos.

Desplácese hacia abajo hasta la segunda celda de código en el cuaderno, que contiene una lista de ignored_columns. De manera predeterminada, el generador de perfiles ignorará todas las columnas, por lo que comentaremos algunas de ellas para asegurarnos de que el generador de perfiles cree expectativas para ellas. Modifique el código para que se vea así:

ignored_columns = [#     "vendor_id"# ,    "pickup_datetime"# ,    "dropoff_datetime"# ,    "passenger_count"    "trip_distance",    "rate_code_id",    "store_and_fwd_flag",    "pickup_location_id",    "dropoff_location_id",    "payment_type",    "fare_amount",    "extra",    "mta_tax",    "tip_amount",    "tolls_amount",    "improvement_surcharge",    "total_amount",    "congestion_surcharge",]

Asegúrese de quitar la coma antes de "trip_distance". Al comentar las columnas vendor_id, pickup_datetime, dropoff_datetimey passenger_count, le está indicando al generador de perfiles que genere Expectativas para esas columnas. Además, el generador de perfiles también generará Expectativas a nivel de tabla , como la cantidad y los nombres de las columnas en sus datos y la cantidad de filas. Una vez más, ejecute todas las celdas en el cuaderno usando la Cell Run Allopción de menú.

Al ejecutar todas las celdas de este cuaderno, suceden dos cosas:

1. El código crea un conjunto de expectativas utilizando el generador de perfiles automatizado y el yellow_tripdata_sample_2019-01.csvarchivo que le indicó que usara.
2. La última celda del cuaderno también está configurada para ejecutar la validación y abrir una nueva ventana del navegador con Data Docs , que es un informe de calidad de datos.

En el siguiente paso, observará más de cerca los documentos de datos que se abrieron en la nueva ventana del navegador.

Paso 4: Exploración de documentos de datos

En este paso del tutorial, inspeccionará los documentos de datos que generó Great Expectations y aprenderá a interpretar los diferentes fragmentos de información. Vaya a la ventana del navegador que acaba de abrir y observe la página que se muestra en la captura de pantalla a continuación.

En la parte superior de la página, verá un cuadro titulado Descripción general , que contiene información sobre la validación que acaba de ejecutar con su conjunto de expectativas recién creado my_suite. Le informará Status: Succeededy mostrará algunas estadísticas básicas sobre cuántas expectativas se ejecutaron. Si se desplaza más hacia abajo, verá una sección titulada Expectativas a nivel de tabla . Contiene dos filas de expectativas, que muestran el estado, la expectativa y el valor observado para cada fila. Debajo de la tabla Expectativas, verá las expectativas a nivel de columna para cada una de las columnas que comentó en el cuaderno.

Centrémonos en una expectativa específica: la passenger_countcolumna tiene una expectativa que indica “los valores deben pertenecer a este conjunto: 1 2 3 4 5 6.”, que está marcada con una marca de verificación verde y tiene un valor observado de “0 % inesperado”. Esto indica que el generador de perfiles examinó los valores de la passenger_countcolumna en el archivo CSV de enero y detectó solo los valores del 1 al 6, lo que significa que todos los viajes en taxi tuvieron entre 1 y 6 pasajeros. Great Expectations luego creó una expectativa para este hecho. La última celda del cuaderno activó la validación del archivo CSV de enero y no encontró valores inesperados. Esto es falsamente cierto, ya que los mismos datos que se usaron para crear la expectativa también fueron los datos utilizados para la validación.

En este paso, revisó los documentos de datos y observó la passenger_countcolumna para determinar su expectativa. En el siguiente paso, verá cómo puede validar un lote de datos diferente.

Paso 5: Creación de un punto de control y ejecución de la validación

En el paso final de este tutorial, creará un nuevo punto de control, que incluye un conjunto de expectativas y un lote de datos para ejecutar la validación de esos datos. Después de crear el punto de control, lo ejecutará para validar el archivo CSV de datos de taxis de febrero y ver si el archivo pasó las expectativas que creó anteriormente. Para comenzar, regrese a su terminal y detenga el cuaderno Jupyter presionando CTRL+Csi aún se está ejecutando. El siguiente comando iniciará el flujo de trabajo para crear un nuevo punto de control llamado my_checkpoint:

great_expectations --v3-api checkpoint new my_checkpoint

Esto abrirá un cuaderno Jupyter con un código precargado para configurar el punto de control. La segunda celda de código del cuaderno tendrá un código precargado aleatorio data_asset_namede su fuente de datos existente, que será uno de los dos archivos CSV en el datadirectorio que vio anteriormente. Asegúrese de que data_asset_namesea así yellow_tripdata_sample_2019-02.csvy modifique el código si es necesario para usar el nombre de archivo correcto.

my_checkpoint_name = "my_checkpoint" # This was populated from your CLI command.yaml_config = f"""name: {my_checkpoint_name}config_version: 1.0class_name: SimpleCheckpointrun_name_template: "%Y%m%d-%H%M%S-my-run-name-template"validations:  - batch_request:      datasource_name: my_datasource      data_connector_name: default_inferred_data_connector_name      data_asset_name: yellow_tripdata_sample_2019-02.csv      data_connector_query:        index: -1    expectation_suite_name: my_suite"""print(yaml_config)"""

Este fragmento de configuración configura un nuevo punto de control, que lee el activo de datos yellow_tripdata_sample_2019-02.csv, es decir, su archivo CSV de febrero, y lo valida mediante Expectation Suite my_suite. Confirme que modificó el código correctamente y luego ejecute todas las celdas en el cuaderno. Esto guardará el nuevo punto de control en su contexto de datos.

Por último, para ejecutar este nuevo punto de control y validar los datos de febrero, desplácese hasta la última celda del cuaderno. Quite el comentario del código de la celda para que quede como sigue:

context.run_checkpoint(checkpoint_name=my_checkpoint_name)context.open_data_docs()

Seleccione la celda y ejecútela mediante la Cell Run Cellsopción de menú o el SHIFT+ENTERatajo de teclado. Esto abrirá Data Docs en una nueva pestaña del navegador.

En la página de descripción general de Resultados de validación, haga clic en la ejecución superior para navegar a la página de detalles de Resultados de validación. La página de detalles de Resultados de validación se verá muy similar a la página que vio en el paso anterior, pero ahora mostrará que Expectation Suite falló y no se pudo validar el nuevo archivo CSV. Desplácese por la página para ver qué Expectations tienen una X roja junto a ellas, lo que las marca como fallidas.

Busque la expectativa en la passenger_countcolumna que miró en el paso anterior: “los valores deben pertenecer a este conjunto: 1 2 3 4 5 6”. Notará que ahora aparece como fallida y resalta que 1579 unexpected values found. ≈15.79% of 10000 total rows. La fila también muestra una muestra de los valores inesperados que se encontraron en la columna, es decir, el valor 0. Esto significa que los datos del viaje en taxi de febrero introdujeron repentinamente el valor inesperado 0como en la passenger_countscolumna, lo que parece un posible error de datos. Al ejecutar el punto de control, validó los nuevos datos con su conjunto de expectativas y detectó este problema.

Tenga en cuenta que cada vez que ejecuta el run_checkpointmétodo en la última celda del cuaderno, inicia otra ejecución de validación. En un entorno de canalización de datos de producción, llamaría al run_checkpointcomando fuera de un cuaderno cada vez que esté procesando un nuevo lote de datos para asegurarse de que los nuevos datos pasen todas las validaciones.

Conclusión

En este artículo, creó una primera implementación local del marco Great Expectations para la validación de datos. Inicializó un contexto de datos de Great Expectations, creó una nueva fuente de datos basada en archivos y generó automáticamente un conjunto de expectativas mediante el generador de perfiles integrado. Luego, creó un punto de control para ejecutar la validación en un nuevo lote de datos e inspeccionó los documentos de datos para ver los resultados de la validación.

Este tutorial solo le enseñó los conceptos básicos de Great Expectations. El paquete contiene más opciones para configurar las fuentes de datos para conectarse a otros tipos de datos, por ejemplo, bases de datos relacionales. También viene con un mecanismo poderoso para reconocer automáticamente nuevos lotes de datos en función de la coincidencia de patrones en el nombre de la tabla o el nombre del archivo, lo que le permite configurar un punto de control solo una vez para validar cualquier entrada de datos futura. Puede obtener más información sobre Great Expectations en la documentación oficial .