Construir Pipelines de Aprendizaje Automático

Capítulo 4. Validación de datos

Este trabajo se ha traducido utilizando IA. Agradecemos tus opiniones y comentarios: [e-mail]

En el Capítulo 3, hablamos de cómo podemos ingerir datos de diversas fuentes en nuestra canalización. En este capítulo, ahora queremos empezar a consumir los datos validándolos, como se muestra en la Figura 4-1.

Figura 4-1. La validación de los datos como parte de las tuberías de ML

Los datos son la base de todo modelo de aprendizaje automático, y la utilidad y el rendimiento del modelo dependen de los datos utilizados para entrenar, validar y analizar el modelo. Como puedes imaginar, sin datos robustos, no podemos construir modelos robustos. En términos coloquiales, es posible que hayas oído la frase: "basura dentro, basura fuera", que significa que nuestros modelos no funcionarán si los datos subyacentes no se curan y validan. Este es el propósito exacto del primer paso de nuestro flujo de trabajo en nuestro proceso de aprendizaje automático: la validación de datos.

En este capítulo, primero motivamos la idea de la validación de datos, y luego te presentamos un paquete Python del ecosistema TensorFlow Extended llamado Validación de Datos TensorFlow (TFDV). Te mostramos cómo puedes configurar el paquete en tus proyectos de ciencia de datos, te guiamos por los casos de uso comunes y destacamos algunos flujos de trabajo muy útiles.

El paso de validación de datos comprueba que los datos de tus conductos son los que espera tu paso de ingeniería de características. Te ayuda a comparar varios conjuntos de datos. También pone de relieve si tus datos cambian con el tiempo, por ejemplo, si tus datos de entrenamiento son significativamente diferentes de los nuevos datos proporcionados a tu modelo para la inferencia.

Al final del capítulo, integramos nuestro primer paso del flujo de trabajo en nuestro canal TFX.

¿Por qué validar los datos?

En el aprendizaje automático, intentamos aprender de los patrones de los conjuntos de datos y generalizar estos aprendizajes. Esto sitúa a los datos en el centro de nuestros flujos de trabajo de aprendizaje automático, y la calidad de los datos se convierte en fundamental para el éxito de nuestros proyectos de aprendizaje automático.

Cada paso de nuestro proceso de aprendizaje automático determina si el flujo de trabajo puede pasar al siguiente paso o si hay que abandonarlo y reiniciarlo (por ejemplo, con más datos de entrenamiento). La validación de datos es un punto de control especialmente importante porque detecta los cambios en los datos que llegan al proceso de aprendizaje automático antes de que lleguen a los pasos de preprocesamiento y entrenamiento, que llevan mucho tiempo.

Si nuestro objetivo es automatizar las actualizaciones de nuestros modelos de aprendizaje automático, es esencial validar nuestros datos. En concreto, cuando decimos validar, nos referimos a tres comprobaciones distintas de nuestros datos:

• Comprueba si hay anomalías en los datos.

• Comprueba que el esquema de datos no ha cambiado.

• Comprueba que las estadísticas de nuestros nuevos conjuntos de datos siguen coincidiendo con las estadísticas de nuestros conjuntos de datos de entrenamiento anteriores.

El paso de validación de datos de nuestro proceso realiza estas comprobaciones y resalta cualquier fallo. Si se detecta un fallo, podemos detener el flujo de trabajo y abordar el problema de los datos a mano, por ejemplo, curando un nuevo conjunto de datos.

También es útil referirse al paso de validación de datos desde el paso de procesamiento de datos, el siguiente paso de nuestro pipeline. La validación de datos produce estadísticas en torno a las características de tus datos y destaca si una característica contiene un alto porcentaje de valores perdidos o si las características están muy correlacionadas. Se trata de una información útil a la hora de decidir qué características deben incluirse en el paso de preprocesamiento y cuál debe ser la forma del preprocesamiento.

La validación de datos te permite comparar las estadísticas de diferentes conjuntos de datos. Este sencillo paso puede ayudarte a depurar los problemas de tu modelo. Por ejemplo, la validación de datos puede comparar las estadísticas de tus datos de entrenamiento con las de tus datos de validación. Con unas pocas líneas de código, llama tu atención sobre cualquier diferencia. Puede que entrenes un modelo de clasificación binaria con una distribución de etiquetas perfecta de 50% de etiquetas positivas y 50% de etiquetas negativas, pero la distribución de etiquetas no es 50/50 en tu conjunto de validación. Esta diferencia en la distribución de etiquetas afectará en última instancia a tus métricas de validación.

En un mundo en el que los conjuntos de datos crecen continuamente, la validación de datos es crucial para asegurarnos de que nuestros modelos de aprendizaje automático siguen estando a la altura. Como podemos comparar esquemas, podemos detectar rápidamente si la estructura de los datos en los conjuntos de datos recién obtenidos ha cambiado (por ejemplo, cuando una característica queda obsoleta). También puede detectar si tus datos empiezan a desviarse. Esto significa que tus datos recién obtenidos tienen estadísticas subyacentes diferentes a las del conjunto de datos inicial utilizado para entrenar tu modelo. Esta deriva podría significar que hay que seleccionar nuevas características o que hay que actualizar los pasos de preprocesamiento de los datos (por ejemplo, si cambia el mínimo o el máximo de una columna numérica). La deriva puede producirse por varias razones: una tendencia subyacente en los datos, la estacionalidad de los datos o como resultado de un bucle de retroalimentación, tal y como tratamos en el Capítulo 13.

En las siguientes secciones, recorreremos estos diferentes casos de uso. Sin embargo, antes de eso, echemos un vistazo a los pasos de instalación necesarios para poner en marcha TFDV.

TFDV

El ecosistema TensorFlow ofrece una herramienta que puede ayudarte en la validación de datos, TFDV. Forma parte del proyecto TFX. TFDV te permite realizar el tipo de análisis que hemos comentado anteriormente (por ejemplo, generar esquemas y validar nuevos datos con respecto a un esquema existente). También ofrece visualizaciones basadas en las Facetas del proyecto PAIR de Google, como se muestra en la Figura 4-2.

TFDV acepta dos formatos de entrada para iniciar la validación de datos: TFRecord de TensorFlow y archivos CSV. Al igual que otros componentes TFX, distribuye el análisis utilizando Apache Beam.

Figura 4-2. Captura de pantalla de una visualización TFDV

Instalación

Cuando instalamos el paquete tfx introducido en el Capítulo 2, TFDV ya estaba instalado como dependencia. Si queremos utilizar TFDV como paquete independiente, podemos instalarlo con este comando:

$ pip install tensorflow-data-validation

Tras instalar tfx o tensorflow-data-validation, ahora podemos integrar nuestra validación de datos en tus flujos de trabajo de aprendizaje automático o analizar nuestros datos visualmente en un Jupyter Notebook. Recorramos un par de casos de uso en las siguientes secciones.

Generar estadísticas a partir de tus datos

El primer paso en nuestro proceso de validación de datos es generar algunas estadísticas resumidas para nuestros datos. Por ejemplo, podemos cargar nuestros datos CSV de reclamaciones de consumidores directamente con TFDV y generar estadísticas para cada característica:

import tensorflow_data_validation as tfdv
stats = tfdv.generate_statistics_from_csv(
    data_location='/data/consumer_complaints.csv',
    delimiter=',')

Podemos generar estadísticas de características a partir de archivos TFRecord de forma muy similar utilizando el siguiente código:

stats = tfdv.generate_statistics_from_tfrecord(
    data_location='/data/consumer_complaints.tfrecord')

En el capítulo 3 veremos cómo generar archivos TFRecord.

Ambos métodos TFDV generan una estructura de datos que almacena los estadísticos de resumen de cada característica, incluidos los valores mínimo, máximo y medio.

La estructura de datos tiene este aspecto

datasets {
  num_examples: 66799
  features {
    type: STRING
    string_stats {
      common_stats {
        num_non_missing: 66799
        min_num_values: 1
        max_num_values: 1
        avg_num_values: 1.0
        num_values_histogram {
          buckets {
            low_value: 1.0
            high_value: 1.0
            sample_count: 6679.9
...
}}}}}}

Para los rasgos numéricos, TFDV calcula para cada rasgo:

• El recuento global de registros de datos

• El número de registros de datos que faltan

• La media y la desviación típica de la característica en todos los registros de datos

• El valor mínimo y máximo de la característica en todos los registros de datos

• El porcentaje de valores cero de la característica en todos los registros de datos

Además, genera un histograma de los valores de cada característica.

Para las características categóricas , TFDV proporciona:

• El recuento global de registros de datos

• El porcentaje de registros de datos que faltan

• El número de registros únicos

• La longitud media de la cadena de todos los registros de una característica

• Para cada categoría, la TFDV determina el recuento de muestras de cada etiqueta y su rango

Dentro de un momento, verás cómo podemos convertir estas estadísticas en algo procesable.

Generar un esquema a partir de tus datos

Una vez que hemos generado nuestras estadísticas resumidas, el siguiente paso es generar un esquema de nuestro conjunto de datos. Los esquemas de datos son una forma de describir la representación de tus conjuntos de datos. Un esquema define qué características se esperan en tu conjunto de datos y en qué tipo se basa cada característica (flotante, entero, bytes, etc.). Además, tu esquema debe definir los límites de tus datos (por ejemplo, esbozar mínimos, máximos y umbrales de registros perdidos permitidos para una característica).

La definición del esquema de tu conjunto de datos puede utilizarse entonces para validar futuros conjuntos de datos y determinar si están en línea con tus conjuntos de entrenamiento anteriores. Los esquemas generados por TFDV también pueden utilizarse en el siguiente paso del flujo de trabajo, cuando estés preprocesando tus conjuntos de datos para convertirlos en datos que puedan utilizarse para entrenar modelos de aprendizaje automático.

Como se muestra a continuación, puedes generar la información del esquema a partir de tus estadísticas generadas con una sola llamada a la función:

schema = tfdv.infer_schema(stats)

tfdv.infer_schema genera un protocolo de esquema definido por TensorFlow:¹

feature {
  name: "product"
  type: BYTES
  domain: "product"
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}

Puedes visualizar el esquema con una sola llamada a la función en cualquier Jupyter Notebook:

tfdv.display_schema(schema)

Y los resultados se muestran en la Figura 4-3.

Figura 4-3. Captura de pantalla de la visualización de un esquema

En esta visualización, Presence significa si la característica debe estar presente en el 100% de los ejemplos de datos (required) o no (optional). Valency significa el número de valores necesarios por ejemplo de entrenamiento. En el caso de las características categóricas, single significaría que cada ejemplo de entrenamiento debe tener exactamente una categoría para la característica.

El esquema que se ha generado aquí puede no ser exactamente lo que necesitamos, porque supone que el conjunto de datos actual es exactamente representativo también de todos los datos futuros. Si una característica está presente en todos los ejemplos de entrenamiento de este conjunto de datos, se marcará como required, pero en realidad puede ser optional. Te mostraremos cómo actualizar el esquema según tu propio conocimiento del conjunto de datos en "Actualizar el esquema".

Con el esquema ya definido, podemos comparar nuestros conjuntos de datos de entrenamiento o de evaluación, o comprobar si hay algún problema que pueda afectar a nuestro modelo.

Reconocer los problemas en tus datos

En los apartados anteriores, hemos hablado de cómo generar estadísticas resumidas y un esquema para nuestros datos. Éstos describen nuestros datos, pero no detectan posibles problemas en ellos. En los siguientes apartados describiremos cómo puede ayudarnos el TFDV a detectar problemas en nuestros datos.

Comparar conjuntos de datos

Supongamos que tenemos dos conjuntos de datos: el de entrenamiento y el de validación. Antes de entrenar nuestro modelo de aprendizaje automático, nos gustaría determinar lo representativo que es el conjunto de validación con respecto al conjunto de entrenamiento. ¿Siguen los datos de validación nuestro esquema de datos de entrenamiento? ¿Falta alguna columna de características o un número significativo de valores de características? Con el TFDV, podemos determinar rápidamente la respuesta.

Como se muestra a continuación, podemos cargar ambos conjuntos de datos y después visualizarlos. Si ejecutamos el siguiente código en un Jupyter Notebook, podremos comparar fácilmente las estadísticas de los conjuntos de datos:

train_stats = tfdv.generate_statistics_from_tfrecord(
    data_location=train_tfrecord_filename)
val_stats = tfdv.generate_statistics_from_tfrecord(
    data_location=val_tfrecord_filename)

tfdv.visualize_statistics(lhs_statistics=val_stats, rhs_statistics=train_stats,
                          lhs_name='VAL_DATASET', rhs_name='TRAIN_DATASET')

La Figura 4-4 muestra la diferencia entre los dos conjuntos de datos. Por ejemplo, el conjunto de datos de validación (que contiene 4.998 registros) tiene una tasa menor de valores sub_issue perdidos. Esto podría significar que la característica está cambiando su distribución en el conjunto de validación. Y lo que es más importante, la visualización puso de manifiesto que más de la mitad de los registros no contienen información sub_issue. Si sub_issue es una característica importante para el entrenamiento de nuestro modelo, tenemos que arreglar nuestros métodos de captura de datos para recoger nuevos datos con los identificadores de incidencia correctos.

El esquema de los datos de entrenamiento que generamos antes resulta ahora muy útil. El TFDV nos permite validar cualquier estadística de datos con respecto al esquema, e informa de cualquier anomalía.

Figura 4-4. Comparación entre los conjuntos de datos de entrenamiento y validación

Las anomalías pueden detectarse utilizando el siguiente código:

anomalies = tfdv.validate_statistics(statistics=val_stats, schema=schema)

Y luego podemos mostrar las anomalías con:

tfdv.display_anomalies(anomalies)

Aparece el resultado que se muestra en la Tabla 4-1.

Tabla 4-1. Visualizar las anomalías en un cuaderno Jupyter

Nombre de la función	Breve descripción de la anomalía	Descripción larga de la anomalía
"empresa"	Columna caída	El rasgo estaba presente en menos ejemplos de los esperados.

El siguiente código muestra el protocolo de anomalías subyacente. Contiene información útil que podemos utilizar para automatizar nuestro flujo de trabajo de aprendizaje automático:

anomaly_info {
  key: "company"
  value {
    description: "The feature was present in fewer examples than expected."
    severity: ERROR
    short_description: "Column dropped"
    reason {
      type: FEATURE_TYPE_LOW_FRACTION_PRESENT
      short_description: "Column dropped"
      description: "The feature was present in fewer examples than expected."
    }
    path {
      step: "company"
    }
  }
}

Actualizar el esquema

El protocolo de anomalías anterior nos muestra cómo detectar variaciones del esquema autogenerado a partir de nuestro conjunto de datos. Pero otro caso de uso del TFDV es establecer manualmente el esquema según nuestro conocimiento del dominio de los datos. Tomando la característica sub_issue comentada anteriormente, si decidimos que necesitamos que esta característica esté presente en más del 90% de nuestros ejemplos de entrenamiento, podemos actualizar el esquema para reflejarlo.

En primer lugar, tenemos que cargar el esquema desde su ubicación serializada:

schema = tfdv.load_schema_text(schema_location)

A continuación, actualizamos esta característica concreta para que sea necesaria en el 90% de los casos:

sub_issue_feature = tfdv.get_feature(schema, 'sub_issue')
sub_issue_feature.presence.min_fraction = 0.9

También podríamos actualizar la lista de estados de EEUU para eliminar Alaska:

state_domain = tfdv.get_domain(schema, 'state')
state_domain.value.remove('AK')

Una vez que estemos satisfechos con el esquema, escribimos el archivo del esquema en su ubicación serializada con lo siguiente:

tfdv.write_schema_text(schema, schema_location)

Luego tenemos que revalidar las estadísticas para ver las anomalías actualizadas:

updated_anomalies = tfdv.validate_statistics(eval_stats, schema)
tfdv.display_anomalies(updated_anomalies)

De este modo, podemos ajustar las anomalías a las que sean adecuadas para nuestro conjunto de datos.²

Desviación y deriva de los datos

El TFDV incorpora un "comparador de asimetría" que detecta grandes diferencias entre las estadísticas de dos conjuntos de datos. No se trata de la definición estadística de sesgo (un conjunto de datos que se distribuye asimétricamente en torno a su media). En el TFDV se define como la norma L-infinita de la diferencia entre las serving_statistics de dos conjuntos de datos. Si la diferencia entre los dos conjuntos de datos supera el umbral de la norma L-infinita para una característica determinada, TFDV la destaca como anomalía utilizando la detección de anomalías definida anteriormente en este capítulo.

Norma L-infinito

La norma L-infinito es una expresión utilizada para definir la diferencia entre dos vectores (en nuestro caso, las estadísticas de servicio). La norma L-infinito se define como el valor absoluto máximo de las entradas del vector.

Por ejemplo, la norma L-infinita del vector [3, -10, -5] es 10. Las normas se utilizan a menudo para comparar vectores. Si queremos comparar los vectores [2, 4, -1] y [9, 1, 8], primero calculamos su diferencia, que es [-7, 3, -9], y luego calculamos la norma L-infinita de este vector, que es 9.

En el caso del TFDV, los dos vectores son los estadísticos de resumen de los dos conjuntos de datos. La norma devuelta es la mayor diferencia entre estos dos conjuntos de estadísticas.

El código siguiente muestra cómo puedes comparar la inclinación entre conjuntos de datos:

tfdv.get_feature(schema,
                 'company').skew_comparator.infinity_norm.threshold = 0.01
skew_anomalies = tfdv.validate_statistics(statistics=train_stats,
                                          schema=schema,
                                          serving_statistics=serving_stats)

Y la Tabla 4-2 muestra los resultados.

Tabla 4-2. Visualización del sesgo de los datos entre los conjuntos de datos de entrenamiento y de servicio

Nombre de la función	Breve descripción de la anomalía	Descripción larga de la anomalía
"empresa"	Gran distancia L-infinita entre el entrenamiento y el servicio	La distancia L-infinita entre el entrenamiento y el servicio es 0,0170752 (hasta seis dígitos significativos), por encima del umbral 0,01. El valor de la característica con la máxima diferencia es Experian

TFDV también proporciona un drift_comparator para comparar las estadísticas de dos conjuntos de datos del mismo tipo, como dos conjuntos de entrenamiento recogidos en dos días diferentes. Si se detecta una desviación, el científico de datos debe comprobar la arquitectura del modelo o determinar si es necesario volver a realizar la ingeniería de características.

De forma similar a este ejemplo de sesgo, debes definir tu drift_comparator para las características que quieras observar y comparar. A continuación, puedes llamar a validate_statistics con las estadísticas de los dos conjuntos de datos como argumentos, uno para tu línea de base (por ejemplo, el conjunto de datos de ayer) y otro para una comparación (por ejemplo, el conjunto de datos de hoy):

tfdv.get_feature(schema,
                 'company').drift_comparator.infinity_norm.threshold = 0.01
drift_anomalies = tfdv.validate_statistics(statistics=train_stats_today,
                                           schema=schema,
                                           previous_statistics=\
                                               train_stats_yesterday)

Y esto da el resultado que se muestra en la Tabla 4-3.

Tabla 4-3. Visualización de la deriva de datos entre dos conjuntos de entrenamiento

Nombre de la función	Breve descripción de la anomalía	Descripción larga de la anomalía
"empresa"	Distancia L-infinita alta entre la actual y la anterior	La distancia L-infinita entre el actual y el anterior es 0,0170752 (hasta seis dígitos significativos), por encima del umbral 0,01. El valor de la característica con la máxima diferencia es Experian

La norma L-infinita, tanto en skew_comparator como en drift_comparator, es útil para mostrarnos grandes diferencias entre conjuntos de datos, sobre todo las que pueden indicarnos que algo va mal en nuestra canalización de entrada de datos. Como la norma L-infinito sólo devuelve un único número, el esquema puede ser más útil para detectar variaciones entre conjuntos de datos.

Conjuntos de datos sesgados

Otro problema potencial de un conjunto de datos de entrada es el sesgo. Definimos sesgo aquí como datos que de alguna manera no son representativos del mundo real. Esto contrasta con la imparcialidad, que definimos en el Capítulo 7 como las predicciones realizadas por nuestro modelo que tienen impactos dispares en diferentes grupos de personas.

El sesgo puede introducirse en los datos de varias maneras. Un conjunto de datos es siempre, por necesidad, un subconjunto del mundo real: no podemos esperar captar todos los detalles de todo. La forma en que muestreamos el mundo real siempre está sesgada de alguna manera. Uno de los tipos de sesgo que podemos comprobar es el sesgo de selección, en el que la distribución del conjunto de datos no coincide con la distribución de los datos en el mundo real.

Podemos utilizar el TFDV para comprobar el sesgo de selección utilizando las visualizaciones estadísticas que hemos descrito anteriormente. Por ejemplo, si nuestro conjunto de datos contiene Gender como característica categórica, podemos comprobar que no está sesgado hacia la categoría masculina. En nuestro conjunto de datos de reclamaciones de consumidores, tenemos State como característica categórica. Lo ideal sería que la distribución de los recuentos de ejemplos en los distintos estados de EE.UU. reflejara la población relativa de cada estado.

Podemos ver en la Figura 4-5 que no es así (por ejemplo, Texas, en tercer lugar, tiene una población mayor que Florida, en segundo lugar). Si encontramos este tipo de sesgo en nuestros datos y creemos que puede perjudicar el rendimiento de nuestro modelo, podemos volver atrás y recoger más datos o sobre/muestrear nuestros datos para obtener la distribución correcta.

Figura 4-5. Visualización de un rasgo sesgado en nuestro conjunto de datos

También puedes utilizar el protocolo de anomalías descrito anteriormente para alertarte automáticamente de este tipo de problemas. Utilizando el conocimiento del dominio que tienes de tu conjunto de datos, puedes imponer límites a los valores numéricos que signifiquen que tu conjunto de datos es lo menos sesgado posible: por ejemplo, si tu conjunto de datos contiene el salario de las personas como característica numérica, puedes imponer que la media del valor de la característica sea realista.

Para más detalles y definiciones de los sesgos, el Curso acelerado de aprendizaje automático de Google tiene material útil.

Trocear datos en TFDV

También podemos utilizar el TFDV para trocear conjuntos de datos sobre características de nuestra elección para ayudar a mostrar si están sesgados. Esto es similar al cálculo del rendimiento del modelo sobre características troceadas que describimos en el Capítulo 7. Por ejemplo, una forma sutil de introducir sesgos en los datos es cuando faltan datos. Si los datos no faltan al azar, pueden faltar con más frecuencia para un grupo de personas dentro del conjunto de datos que para otros. Esto puede significar que cuando se entrene el modelo final, su rendimiento sea peor para estos grupos.

En este ejemplo, veremos datos de diferentes estados de EEUU. Podemos trocear los datos de modo que sólo obtengamos estadísticas de California utilizando el siguiente código:

from tensorflow_data_validation.utils import slicing_util

slice_fn1 = slicing_util.get_feature_value_slicer(
    features={'state': [b'CA']}) 
slice_options = tfdv.StatsOptions(slice_functions=[slice_fn1])
slice_stats = tfdv.generate_statistics_from_csv(
    data_location='data/consumer_complaints.csv',
    stats_options=slice_options)

Ten en cuenta que el valor de la característica debe proporcionarse como una lista de valores binarios.

Necesitamos un código de ayuda para copiar las estadísticas troceadas en la visualización:

from tensorflow_metadata.proto.v0 import statistics_pb2

def display_slice_keys(stats):
    print(list(map(lambda x: x.name, slice_stats.datasets)))

def get_sliced_stats(stats, slice_key):
    for sliced_stats in stats.datasets:
        if sliced_stats.name == slice_key:
            result = statistics_pb2.DatasetFeatureStatisticsList()
            result.datasets.add().CopyFrom(sliced_stats)
            return result
        print('Invalid Slice key')

def compare_slices(stats, slice_key1, slice_key2):
    lhs_stats = get_sliced_stats(stats, slice_key1)
    rhs_stats = get_sliced_stats(stats, slice_key2)
    tfdv.visualize_statistics(lhs_stats, rhs_stats)

Y podemos visualizar los resultados con el siguiente código:

tfdv.visualize_statistics(get_sliced_stats(slice_stats, 'state_CA'))

Y luego compara las estadísticas de California con los resultados globales:

compare_slices(slice_stats, 'state_CA', 'All Examples')

Los resultados se muestran en la Figura 4-6.

Figura 4-6. Visualización de datos divididos por valores de características

En esta sección, hemos mostrado algunas funciones útiles de TFDV que te permiten detectar problemas en tus datos. A continuación, veremos cómo ampliar la validación de tus datos utilizando un producto de Google Cloud.

Procesamiento de grandes conjuntos de datos con GCP

A medida que recopilamos más datos, la validación de los datos se convierte en un paso que requiere más tiempo en nuestro flujo de trabajo de aprendizaje automático. Una forma de reducir el tiempo necesario para realizar la validación es aprovechar las soluciones disponibles en la nube. Al utilizar un proveedor en la nube, no estamos limitados a la potencia de cálculo de nuestro portátil o a los recursos informáticos locales.

Como ejemplo, presentaremos cómo ejecutar TFDV en el producto Dataflow de Google Cloud. TFDV se ejecuta en Apache Beam, lo que facilita mucho el cambio a GCP Dataflow.

Dataflow nos permite acelerar nuestras tareas de validación de datos paralelizándolas y distribuyéndolas entre los nodos asignados para nuestra tarea de procesamiento de datos. Aunque Dataflow cobra por el número de CPUs y los gigabytes de memoria asignados, puede acelerar nuestro paso de pipeline.

Demostraremos una configuración mínima para distribuir nuestras tareas de validación de datos. Para más información, recomendamos encarecidamente la documentación ampliada de GCP. Suponemos que tienes una cuenta de Google Cloud creada, los datos de facturación configurados y la variable de entorno GOOGLE_APPLICATION_CREDENTIALS en tu shell de terminal. Si necesitas ayuda para empezar, consulta el Capítulo 3 o la documentación de Google Cloud.

Podemos utilizar el mismo método del que hablamos anteriormente (por ejemplo, tfdv.generate_statistics_from_tfrecord), pero los métodos requieren los argumentos adicionales pipeline_options y output_path. Mientras que output_path apunta al bucket de Google Cloud donde deben escribirse los resultados de la validación de datos, pipeline_options es un objeto que contiene todos los detalles de Google Cloud para ejecutar nuestra validación de datos en Google Cloud. El siguiente código muestra cómo podemos configurar como un objeto pipeline:

from apache_beam.options.pipeline_options import (
    PipelineOptions, GoogleCloudOptions, StandardOptions)

options = PipelineOptions()
google_cloud_options = options.view_as(GoogleCloudOptions)
google_cloud_options.project = '<YOUR_GCP_PROJECT_ID>' 
google_cloud_options.job_name = '<YOUR_JOB_NAME>' 
google_cloud_options.staging_location = 'gs://<YOUR_GCP_BUCKET>/staging' 
google_cloud_options.temp_location = 'gs://<YOUR_GCP_BUCKET>/tmp'
options.view_as(StandardOptions).runner = 'DataflowRunner'

Establece el identificador de tu proyecto.

Dale un nombre a tu trabajo.

Apunta hacia un cubo de almacenamiento para archivos temporales y de preparación.

Te recomendamos que crees un cubo de almacenamiento para tus tareas Dataflow. El cubo de almacenamiento contendrá todos los conjuntos de datos y archivos temporales.

Una vez configuradas las opciones de Google Cloud, tenemos que configurar la configuración de los trabajadores de Dataflow. Todas las tareas se ejecutan en trabajadores que necesitan ser aprovisionados con los paquetes necesarios para ejecutar sus tareas. En nuestro caso, necesitamos instalar TFDV especificándolo como paquete adicional.

Para ello, descarga el último paquete TFDV (el archivo binario .whl )³ a tu sistema local. Elige una versión que pueda ejecutarse en un sistema Linux (por ejemplo, tensorflow_data_validation-0.22.0-cp37-cp37m-manylinux2010_x86_64.whl).

Para configurar las opciones de configuración del trabajador, especifica la ruta del paquete descargado en la lista setup_options.extra_packages, como se muestra:

from apache_beam.options.pipeline_options import SetupOptions

setup_options = options.view_as(SetupOptions)
setup_options.extra_packages = [
    '/path/to/tensorflow_data_validation'
    '-0.22.0-cp37-cp37m-manylinux2010_x86_64.whl']

Una vez configuradas todas las opciones, puedes iniciar las tareas de validación de datos desde tu máquina local. Se ejecutan en las instancias de Google Cloud Dataflow:

data_set_path = 'gs://<YOUR_GCP_BUCKET>/train_reviews.tfrecord'
output_path = 'gs://<YOUR_GCP_BUCKET>/'
tfdv.generate_statistics_from_tfrecord(data_set_path,
                                       output_path=output_path,
                                       pipeline_options=options)

Una vez iniciada la validación de datos con Dataflow, puedes volver a la consola de Google Cloud. Tu trabajo recién iniciado debería aparecer en una lista similar a la de la Figura 4-7.

Figura 4-7. Consola de Google Cloud Dataflow Jobs

A continuación, puedes comprobar los detalles del trabajo en ejecución, su estado y sus detalles de autoescalado, como se muestra en la Figura 4-8.

Puedes ver que con unos pocos pasos puedes paralelizar y distribuir las tareas de validación de datos en un entorno de nube. En la siguiente sección, hablaremos de la integración de las tareas de validación de datos en nuestros pipelines automatizados de aprendizaje automático.

Figura 4-8. Detalles del trabajo de Google Cloud Dataflow

Integrar el TFDV en tu proceso de aprendizaje automático

Hasta ahora, todos los métodos que hemos discutido pueden utilizarse en una configuración independiente. Esto puede ser útil para investigar conjuntos de datos fuera de la configuración de la tubería.

TFX proporciona un componente de canalización llamado StatisticsGen, que acepta la salida de los componentes anteriores de ExampleGen como entrada y luego realiza la generación de estadísticas:

from tfx.components import StatisticsGen

statistics_gen = StatisticsGen(
    examples=example_gen.outputs['examples'])
context.run(statistics_gen)

Al igual que comentamos en el Capítulo 3, podemos visualizar el resultado en un contexto interactivo utilizando:

context.show(statistics_gen.outputs['statistics'])

Esto nos da la visualización mostrada en la Figura 4-9.

Figura 4-9. Estadísticas generadas por el componente StatisticsGen

Generar nuestro esquema es tan fácil como generar las estadísticas:

from tfx.components import SchemaGen

schema_gen = SchemaGen(
    statistics=statistics_gen.outputs['statistics'],
    infer_feature_shape=True)
context.run(schema_gen)

El componente SchemaGen sólo genera un esquema si no existe ya uno. Es una buena idea revisar el esquema en la primera ejecución de este componente y luego ajustarlo manualmente si es necesario, tal y como comentamos en "Actualizar el esquema". Entonces podremos utilizar este esquema hasta que sea necesario cambiarlo, por ejemplo, si añadimos una nueva función.

Con las estadísticas y el esquema listos, ya podemos validar nuestro nuevo conjunto de datos:

from tfx.components import ExampleValidator

example_validator = ExampleValidator(
    statistics=statistics_gen.outputs['statistics'],
    schema=schema_gen.outputs['schema'])
context.run(example_validator)

Nota

El ExampleValidator puede detectar automáticamente las anomalías con respecto al esquema utilizando los comparadores de desviación y deriva que hemos descrito anteriormente. Sin embargo, esto puede no cubrir todas las anomalías potenciales de tus datos. Si necesitas detectar algunas otras anomalías específicas, tendrás que escribir tu propio componente personalizado, como describimos en el Capítulo 10.

Si el componente ExampleValidator detecta un desajuste en las estadísticas o el esquema del conjunto de datos entre el conjunto de datos nuevo y el anterior, establecerá el estado en fallido en el almacén de metadatos, y el conducto se detendrá en última instancia. De lo contrario, la cadena pasa al siguiente paso, el preprocesamiento de datos.

Resumen

En este capítulo, hemos hablado de la importancia de la validación de datos y de cómo puedes realizar y automatizar eficazmente el proceso. Discutimos cómo generar estadísticas y esquemas de datos y cómo comparar dos conjuntos de datos diferentes basándonos en sus estadísticas y esquemas. Pasamos por un ejemplo de cómo podrías ejecutar tu validación de datos en Google Cloud con Dataflow, y finalmente integramos este paso de aprendizaje automático en nuestra canalización automatizada. Se trata de un paso muy importante en nuestro proceso, ya que evita que los datos sucios pasen a los pasos de preprocesamiento y entrenamiento, que consumen mucho tiempo.

En los capítulos siguientes, ampliaremos la configuración de nuestro pipeline empezando por el preprocesamiento de los datos.

¹ Puedes encontrar las definiciones del búfer de protocolo para el protocolo de esquema en el repositorio de TensorFlow.

² También puedes ajustar el esquema para que se requieran distintas funciones en los entornos de formación y de servicio. Consulta la documentación para más detalles.

³ Descarga los paquetes TFDV.