Aide à protéger la Grande barrière de corail avec tensorflow sur Kaggle Rejoignez Défi

Premiers pas avec la validation des données Tensorflow

Tensorflow Data Validation (TFDV) peut analyser les données d'entraînement et de diffusion pour :

L'API principale prend en charge chaque élément de fonctionnalité, avec des méthodes pratiques qui s'appuient sur le dessus et peuvent être appelées dans le contexte des blocs-notes.

Calcul de statistiques de données descriptives

TFDV peut calculer descriptives des statistiques qui donnent un aperçu rapide des données en fonction des caractéristiques qui sont présentes et les formes de leurs distributions de valeur. Des outils tels que Facettes Vue d' ensemble peuvent fournir une visualisation succincte de ces statistiques pour faciliter la navigation.

Par exemple, supposons que path pointe vers un fichier dans le TFRecord le format (qui contient des enregistrements de type tensorflow.Example ). L'extrait suivant illustre le calcul des statistiques à l'aide de TFDV :

    stats = tfdv.generate_statistics_from_tfrecord(data_location=path)

La valeur renvoyée est un DatasetFeatureStatisticsList tampon de protocole. Le bloc - notes par exemple contient une visualisation des statistiques à l' aide Facettes Vue d' ensemble :

    tfdv.visualize_statistics(stats)

Capture d'écran de la visualisation des statistiques

L'exemple précédent suppose que les données sont stockées dans un TFRecord fichier. TFDV prend également en charge le format d'entrée CSV, avec une extensibilité pour d'autres formats courants. Vous pouvez trouver les décodeurs de données disponibles ici . En outre, TFDV fournit la tfdv.generate_statistics_from_dataframe fonction d'utilité pour les utilisateurs avec des données en mémoire représentés comme une trame de données panda.

En plus de calculer un ensemble par défaut de statistiques de données, TFDV peut également calculer des statistiques pour des domaines sémantiques (par exemple, des images, du texte). Pour permettre le calcul des statistiques sémantiques de domaine, passer un tfdv.StatsOptions objet avec enable_semantic_domain_stats définie sur True à tfdv.generate_statistics_from_tfrecord .

Exécution sur Google Cloud

En interne, TFDV utilise Apache faisceau cadre de traitement parallèle des données de calcul à l' échelle des statistiques sur les grands ensembles de données. Pour les applications qui souhaitent intégrer plus profonde avec TFDV (par exemple attach la génération de statistiques à la fin d'un pipeline génération de données, générer des statistiques pour les données en format personnalisé ), l'API expose également un faisceau PTransform pour la production de statistiques.

Pour exécuter TFDV sur Google Cloud, le fichier de roue TFDV doit être téléchargé et fourni aux nœuds de calcul Dataflow. Téléchargez le fichier wheel dans le répertoire actuel comme suit :

pip download tensorflow_data_validation \
  --no-deps \
  --platform manylinux1_x86_64 \
  --only-binary=:all:

L'extrait suivant montre un exemple d'utilisation de TFDV sur Google Cloud :


import tensorflow_data_validation as tfdv
from apache_beam.options.pipeline_options import PipelineOptions, GoogleCloudOptions, StandardOptions, SetupOptions

PROJECT_ID = ''
JOB_NAME = ''
GCS_STAGING_LOCATION = ''
GCS_TMP_LOCATION = ''
GCS_DATA_LOCATION = ''
# GCS_STATS_OUTPUT_PATH is the file path to which to output the data statistics
# result.
GCS_STATS_OUTPUT_PATH = ''

PATH_TO_WHL_FILE = ''


# Create and set your PipelineOptions.
options = PipelineOptions()

# For Cloud execution, set the Cloud Platform project, job_name,
# staging location, temp_location and specify DataflowRunner.
google_cloud_options = options.view_as(GoogleCloudOptions)
google_cloud_options.project = PROJECT_ID
google_cloud_options.job_name = JOB_NAME
google_cloud_options.staging_location = GCS_STAGING_LOCATION
google_cloud_options.temp_location = GCS_TMP_LOCATION
options.view_as(StandardOptions).runner = 'DataflowRunner'

setup_options = options.view_as(SetupOptions)
# PATH_TO_WHL_FILE should point to the downloaded tfdv wheel file.
setup_options.extra_packages = [PATH_TO_WHL_FILE]

tfdv.generate_statistics_from_tfrecord(GCS_DATA_LOCATION,
                                       output_path=GCS_STATS_OUTPUT_PATH,
                                       pipeline_options=options)

Dans ce cas, les statistiques produites proto est stocké dans un fichier TFRecord écrit GCS_STATS_OUTPUT_PATH .

REMARQUE Lorsque vous appelez l' un des tfdv.generate_statistics_... fonctions (par exemple, tfdv.generate_statistics_from_tfrecord sur Google Cloud), vous devez fournir un output_path . La spécification de Aucun peut provoquer une erreur.

Déduire un schéma sur les données

Le schéma décrit les propriétés attendues des données. Certaines de ces propriétés sont :

  • quelles fonctionnalités devraient être présentes
  • leur genre
  • le nombre de valeurs pour une caractéristique dans chaque exemple
  • la présence de chaque caractéristique dans tous les exemples
  • les domaines de fonctionnalités attendus.

En bref, le schéma décrit les attentes en matière de données « correctes » et peut donc être utilisé pour détecter des erreurs dans les données (décrites ci-dessous). De plus, le même schéma peut être utilisé pour mettre en place tensorflow Transformer pour les transformations de données. Notez que le schéma est censé être assez statique, par exemple, plusieurs ensembles de données peuvent se conformer au même schéma, alors que les statistiques (décrites ci-dessus) peuvent varier par ensemble de données.

Étant donné que l'écriture d'un schéma peut être une tâche fastidieuse, en particulier pour les ensembles de données avec de nombreuses fonctionnalités, TFDV fournit une méthode pour générer une version initiale du schéma basée sur les statistiques descriptives :

    schema = tfdv.infer_schema(stats)

En général, TFDV utilise des heuristiques conservatrices pour déduire des propriétés de données stables à partir des statistiques afin d'éviter de suradapter le schéma à l'ensemble de données spécifique. Il est fortement conseillé d'examiner le schéma inféré et d' affiner au besoin, de saisir toute connaissance de domaine sur les données que les heuristiques de TFDV aurait pu manquer.

Par défaut, tfdv.infer_schema infère la forme de chaque fonction requise, si value_count.min est égal à value_count.max pour la fonction. Réglez le infer_feature_shape argument False pour l' inférence de forme désactiver.

Le schéma lui - même est stockée sous la forme d' un tampon de protocole de schéma et peut donc être mis à jour / modifié en utilisant l'API de protocole tampon standard. TFDV fournit également un petit nombre de méthodes utilitaires pour rendre ces mises à jour plus facile. Par exemple, supposons que le schéma contient la strophe suivante pour décrire une caractéristique chaîne requise payment_type qui prend une valeur unique:

feature {
  name: "payment_type"
  value_count {
    min: 1
    max: 1
  }
  type: BYTES
  domain: "payment_type"
  presence {
    min_fraction: 1.0
    min_count: 1
  }
}

Pour marquer que la fonctionnalité doit être renseignée dans au moins 50 % des exemples :

    tfdv.get_feature(schema, 'payment_type').presence.min_fraction = 0.5

Le bloc - notes par exemple contient une simple visualisation du schéma comme une table, énumérant chaque fonction et ses caractéristiques principales telles qu'elles sont encodées dans le schéma.

Capture d'écran de la visualisation du schéma

Vérification des données pour les erreurs

Compte tenu d' un schéma, il est possible de vérifier si un ensemble de données est conforme aux attentes définies dans le schéma ou s'il existe des anomalies de données . Vous pouvez vérifier vos données pour les erreurs (a) dans l'agrégat sur un ensemble de données entier en faisant correspondre les statistiques de l'ensemble de données avec le schéma, ou (b) en recherchant les erreurs sur une base par exemple.

Faire correspondre les statistiques de l'ensemble de données à un schéma

Pour vérifier les erreurs dans l'agrégat, TFDV compare les statistiques de l'ensemble de données au schéma et marque les écarts. Par exemple:

    # Assume that other_path points to another TFRecord file
    other_stats = tfdv.generate_statistics_from_tfrecord(data_location=other_path)
    anomalies = tfdv.validate_statistics(statistics=other_stats, schema=schema)

Le résultat est une instance du Anomalies tampon de protocole et décrit les erreurs où les statistiques ne sont pas d' accord avec le schéma. Par exemple, supposons que les données à other_path contient des exemples des valeurs de la fonction payment_type en dehors du domaine spécifié dans le schéma.

Cela produit une anomalie

   payment_type  Unexpected string values  Examples contain values missing from the schema: Prcard (<1%).

indiquant qu'une valeur hors domaine a été trouvée dans les statistiques dans < 1 % des valeurs de caractéristiques.

Si cela était attendu, le schéma peut être mis à jour comme suit :

   tfdv.get_domain(schema, 'payment_type').value.append('Prcard')

Si l'anomalie indique vraiment une erreur de données, les données sous-jacentes doivent être corrigées avant de les utiliser pour l'apprentissage.

Les différents types d'anomalies qui peuvent être détectées par ce module sont listés ici .

Le bloc - notes par exemple contient une simple visualisation des anomalies comme une table, énumérant les caractéristiques où les erreurs sont détectées et une brève description de chaque erreur.

Capture d'écran des anomalies

Vérification des erreurs par exemple

TFDV offre également la possibilité de valider les données par exemple, au lieu de comparer les statistiques de l'ensemble de données avec le schéma. TFDV fournit des fonctions pour valider les données par exemple, puis générer des statistiques récapitulatives pour les exemples anormaux trouvés. Par exemple:

   options = tfdv.StatsOptions(schema=schema)
   anomalous_example_stats = tfdv.validate_examples_in_tfrecord(
       data_location=input, stats_options=options)

Les anomalous_example_stats que validate_examples_in_tfrecord retours est un DatasetFeatureStatisticsList tampon de protocole dans lequel chaque jeu de données se compose de l'ensemble des exemples qui présentent une anomalie particulière. Vous pouvez l'utiliser pour déterminer le nombre d'exemples dans votre ensemble de données qui présentent une anomalie donnée et les caractéristiques de ces exemples.

TFDV fournit également la validate_instance fonction pour identifier si un individu présente des anomalies exemple en cas de concordance contre un schéma. Pour utiliser cette fonction, l'exemple doit être un dict mappant des noms de caractéristiques à des tableaux numpy de valeurs de caractéristiques. Vous pouvez utiliser le décodeur dans tfx_bsl à décoder sérialisé tf.train.Example s dans ce format. Par exemple:

   import tensorflow_data_validation as tfdv
   import tfx_bsl
   import pyarrow as pa
   decoder = tfx_bsl.coders.example_coder.ExamplesToRecordBatchDecoder()
   example = decoder.DecodeBatch([serialized_tfexample])
   options = tfdv.StatsOptions(schema=schema)
   anomalies = tfdv.validate_instance(example, options)

Comme avec validate_statistics , le résultat est une instance du Anomalies tampon de protocole qui décrit les erreurs où l'exemple ne sont pas d' accord avec le schéma indiqué.

Environnements de schéma

Par défaut, les validations supposent que tous les ensembles de données d'un pipeline adhèrent à un seul schéma. Dans certains cas, l'introduction de légères variations de schéma est nécessaire, par exemple les fonctionnalités utilisées comme étiquettes sont requises lors de l'entraînement (et doivent être validées), mais manquent lors de la diffusion.

Les environnements peuvent être utilisés pour exprimer ces exigences. En particulier, les fonctionnalités du schéma peuvent être associées à un ensemble d'environnements utilisant default_environment, in_environment et not_in_environment.

Par exemple, si la fonction des conseils est utilisé comme étiquette dans la formation, mais il manque dans les données de service. Sans environnement spécifié, il apparaîtra comme une anomalie.

    serving_stats = tfdv.generate_statistics_from_tfrecord(data_location=serving_data_path)
    serving_anomalies = tfdv.validate_statistics(serving_stats, schema)

Capture d'écran des anomalies de diffusion

Pour résoudre ce problème, nous devons définir l'environnement par défaut pour toutes les fonctionnalités comme étant à la fois « FORMATION » et « SERVING », et exclure la fonctionnalité « conseils » de l'environnement SERVIR.

    # All features are by default in both TRAINING and SERVING environments.
    schema.default_environment.append('TRAINING')
    schema.default_environment.append('SERVING')

    # Specify that 'tips' feature is not in SERVING environment.
    tfdv.get_feature(schema, 'tips').not_in_environment.append('SERVING')

    serving_anomalies_with_env = tfdv.validate_statistics(
        serving_stats, schema, environment='SERVING')

Vérification de l'asymétrie et de la dérive des données

En plus de vérifier si un jeu de données est conforme aux attentes définies dans le schéma, TFDV fournit également des fonctionnalités pour détecter :

  • décalage entre les données d'entraînement et de diffusion
  • dérive entre les différents jours de données d'entraînement

TFDV effectue cette vérification en comparant les statistiques de différents ensembles de données sur la base des comparateurs de dérive/d'asymétrie spécifiés dans le schéma. Par exemple, pour vérifier s'il existe un décalage entre la fonctionnalité "payment_type" dans l'ensemble de données d'entraînement et de diffusion :

    # Assume we have already generated the statistics of training dataset, and
    # inferred a schema from it.
    serving_stats = tfdv.generate_statistics_from_tfrecord(data_location=serving_data_path)
    # Add a skew comparator to schema for 'payment_type' and set the threshold
    # of L-infinity norm for triggering skew anomaly to be 0.01.
    tfdv.get_feature(schema, 'payment_type').skew_comparator.infinity_norm.threshold = 0.01
    skew_anomalies = tfdv.validate_statistics(
        statistics=train_stats, schema=schema, serving_statistics=serving_stats)

Même avec vérifier si un ensemble de données sont conformes aux attentes définies dans le schéma, le résultat est également une instance du Anomalies tampon de protocole et décrit tout biais entre la formation et les ensembles de données au service. Par exemple, supposons que les données qui servent contient des exemples beaucoup plus avec fonction payement_type ayant une valeur de Cash , ce qui produit une anomalie biais

   payment_type  High L-infinity distance between serving and training  The L-infinity distance between serving and training is 0.0435984 (up to six significant digits), above the threshold 0.01. The feature value with maximum difference is: Cash

Si l'anomalie indique vraiment un décalage entre les données d'entraînement et de diffusion, une enquête plus approfondie est nécessaire car cela pourrait avoir un impact direct sur les performances du modèle.

Le portable exemple contient un exemple simple de vérifier des anomalies à base d'inclinaison.

La détection de la dérive entre les différents jours des données d'entraînement peut être effectuée de la même manière

    # Assume we have already generated the statistics of training dataset for
    # day 2, and inferred a schema from it.
    train_day1_stats = tfdv.generate_statistics_from_tfrecord(data_location=train_day1_data_path)
    # Add a drift comparator to schema for 'payment_type' and set the threshold
    # of L-infinity norm for triggering drift anomaly to be 0.01.
    tfdv.get_feature(schema, 'payment_type').drift_comparator.infinity_norm.threshold = 0.01
    drift_anomalies = tfdv.validate_statistics(
        statistics=train_day2_stats, schema=schema, previous_statistics=train_day1_stats)

Écriture du connecteur de données personnalisé

Pour les statistiques de données de calcul, TFDV propose plusieurs méthodes pratiques pour la gestion des données d'entrée dans différents formats (par exemple TFRecord de tf.train.Example , CSV, etc.). Si votre format de données ne figure pas dans cette liste, vous devez écrire un connecteur de données personnalisé pour lire les données d'entrée et le connecter à l'API principale TFDV pour calculer les statistiques de données.

Le TFDV API de base pour le DatasetFeatureStatisticsList calcul de données statistiques est un PTransform faisceau qui prend un PCollection des lots d'exemples d'entrée (un lot d'exemples d'entrée est représentée par une flèche RecordBatch), et délivre en sortie un PCollection contenant un seul DatasetFeatureStatisticsList tampon de protocole.

Une fois que vous avez mis en place le connecteur de données personnalisées que les lots vos exemples d'entrée dans une flèche RecordBatch, vous devez vous connecter avec l' tfdv.GenerateStatistics API pour le calcul des données statistiques. Prenez TFRecord de tf.train.Example « s par exemple. Nous fournissons le DecodeTFExample connecteur de données, et au- dessous est un exemple de la façon de se connecter avec l' tfdv.GenerateStatistics API.

import tensorflow_data_validation as tfdv
import apache_beam as beam
from tensorflow_metadata.proto.v0 import statistics_pb2

DATA_LOCATION = ''
OUTPUT_LOCATION = ''

with beam.Pipeline() as p:
    _ = (
    p
    # 1. Read out the examples from input files.
    | 'ReadData' >> beam.io.ReadFromTFRecord(file_pattern=DATA_LOCATION)
    # 2. Convert examples to Arrow RecordBatches, which represent example
    #    batches.
    | 'DecodeData' >> tf_example_decoder.DecodeTFExample()
    # 3. Invoke TFDV `GenerateStatistics` API to compute the data statistics.
    | 'GenerateStatistics' >> tfdv.GenerateStatistics()
    # 4. Materialize the generated data statistics.
    | 'WriteStatsOutput' >> WriteStatisticsToTFRecord(OUTPUT_LOCATION))

Calcul de statistiques sur des tranches de données

TFDV peut être configuré pour calculer des statistiques sur des tranches de données. Trancheuse peut être activée en fournissant des fonctions de tranchage qui prennent en une flèche RecordBatch et sortie une séquence de tuples de forme (slice key, record batch) . TFDV fournit un moyen facile de générer des tfdv.StatsOptions fonctions de découpage sur la base de la valeur de fonction qui peuvent être fournis dans le cadre de tfdv.StatsOptions lorsque le calcul de statistiques.

Lorsque le découpage est activé, la sortie DatasetFeatureStatisticsList proto contient plusieurs DatasetFeatureStatistics protos, un pour chaque tranche. Chaque tranche est identifié par un nom unique qui est défini comme le nom du jeu de données dans le DatasetFeatureStatistics proto . Par défaut, TFDV calcule des statistiques pour l'ensemble de données global en plus des tranches configurées.

import tensorflow_data_validation as tfdv
from tensorflow_data_validation.utils import slicing_util

# Slice on country feature (i.e., every unique value of the feature).
slice_fn1 = slicing_util.get_feature_value_slicer(features={'country': None})

# Slice on the cross of country and state feature (i.e., every unique pair of
# values of the cross).
slice_fn2 = slicing_util.get_feature_value_slicer(
    features={'country': None, 'state': None})

# Slice on specific values of a feature.
slice_fn3 = slicing_util.get_feature_value_slicer(
    features={'age': [10, 50, 70]})

stats_options = tfdv.StatsOptions(
    slice_functions=[slice_fn1, slice_fn2, slice_fn3])