Rejoignez la communauté SIG TFX-Addons et contribuez à rendre TFX encore meilleur ! Rejoignez SIG TFX-Addons

Validation des données TensorFlow

Exemple de composant clé de TensorFlow Extended

Cet exemple de bloc-notes Colab illustre comment TensorFlow Data Validation (TFDV) peut être utilisé pour étudier et visualiser votre ensemble de données. Cela inclut l'examen des statistiques descriptives, la déduction d'un schéma, la vérification et la correction des anomalies, ainsi que la vérification des dérives et des biais dans notre ensemble de données. Il est important de comprendre les caractéristiques de votre ensemble de données, y compris la façon dont il peut évoluer au fil du temps dans votre pipeline de production. Il est également important de rechercher des anomalies dans vos données et de comparer vos ensembles de données d'entraînement, d'évaluation et de diffusion pour vous assurer qu'ils sont cohérents.

Nous allons utiliser les données du taxi Trips ensemble de données publié par la ville de Chicago.

En savoir plus sur l'ensemble de données dans Google BigQuery . Explorez l'ensemble des données dans l' interface utilisateur BigQuery .

Les colonnes de l'ensemble de données sont :

zone_de_collecte_de_communauté tarif voyage_début_mois
trip_start_hour trip_start_day trip_start_timestamp
ramassage_latitude ramassage_longitude dropoff_latitude
dropoff_longitude voyage_miles pick_census_tract
dropoff_census_tract type de paiement entreprise
trip_secondes dropoff_community_area des astuces

Pip de mise à niveau

Pour éviter de mettre à niveau Pip dans un système lors de l'exécution locale, assurez-vous que nous exécutons dans Colab. Les systèmes locaux peuvent bien sûr être mis à niveau séparément.

try:
  import colab
  !pip install --upgrade pip
except:
  pass

Installer TensorFlow

pip install tensorflow==2.2.0

Vérifier la version Python

import sys

# Confirm that we're using Python 3
assert sys.version_info.major is 3, 'Oops, not running Python 3. Use Runtime > Change runtime type'

Installer TFDV

Cela va extraire toutes les dépendances, ce qui prendra une minute. Veuillez ignorer les avertissements ou les erreurs concernant les versions de dépendances incompatibles.

import tensorflow as tf

print('Installing TensorFlow Data Validation')
!pip install -q tensorflow_data_validation[visualization]

As-tu redémarré le runtime ?

Si vous utilisez Google Colab, la première fois que vous exécutez la cellule ci-dessus, vous devez redémarrer le runtime (Runtime > Redémarrer le runtime...). Cela est dû à la façon dont Colab charge les packages.

Charger les fichiers

Nous allons télécharger notre ensemble de données à partir de Google Cloud Storage.

import os
import tempfile, urllib, zipfile

# Set up some globals for our file paths
BASE_DIR = tempfile.mkdtemp()
DATA_DIR = os.path.join(BASE_DIR, 'data')
OUTPUT_DIR = os.path.join(BASE_DIR, 'chicago_taxi_output')
TRAIN_DATA = os.path.join(DATA_DIR, 'train', 'data.csv')
EVAL_DATA = os.path.join(DATA_DIR, 'eval', 'data.csv')
SERVING_DATA = os.path.join(DATA_DIR, 'serving', 'data.csv')

# Download the zip file from GCP and unzip it
zip, headers = urllib.request.urlretrieve('https://storage.googleapis.com/artifacts.tfx-oss-public.appspot.com/datasets/chicago_data.zip')
zipfile.ZipFile(zip).extractall(BASE_DIR)
zipfile.ZipFile(zip).close()

print("Here's what we downloaded:")
!ls -R {os.path.join(BASE_DIR, 'data')}
Here's what we downloaded:
/tmp/tmp9ac2o66s/data:
eval  serving  train

/tmp/tmp9ac2o66s/data/eval:
data.csv

/tmp/tmp9ac2o66s/data/serving:
data.csv

/tmp/tmp9ac2o66s/data/train:
data.csv

Vérifiez la version

import tensorflow_data_validation as tfdv
print('TFDV version: {}'.format(tfdv.version.__version__))
TFDV version: 0.27.0

Calculer et visualiser des statistiques

D' abord , nous allons utiliser tfdv.generate_statistics_from_csv les statistiques pour calculer nos données de formation. (ignorez les avertissements accrocheurs)

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.

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 s'intégrer plus profondément avec TFDV (par exemple, attacher la génération de statistiques à la fin d'un pipeline de génération de données), l'API expose également un Beam PTransform pour la génération de statistiques.

train_stats = tfdv.generate_statistics_from_csv(data_location=TRAIN_DATA)
WARNING:apache_beam.runners.interactive.interactive_environment:Dependencies required for Interactive Beam PCollection visualization are not available, please use: `pip install apache-beam[interactive]` to install necessary dependencies to enable all data visualization features.
WARNING:apache_beam.io.tfrecordio:Couldn't find python-snappy so the implementation of _TFRecordUtil._masked_crc32c is not as fast as it could be.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_data_validation/utils/stats_util.py:247: tf_record_iterator (from tensorflow.python.lib.io.tf_record) is deprecated and will be removed in a future version.
Instructions for updating:
Use eager execution and: 
`tf.data.TFRecordDataset(path)`
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_data_validation/utils/stats_util.py:247: tf_record_iterator (from tensorflow.python.lib.io.tf_record) is deprecated and will be removed in a future version.
Instructions for updating:
Use eager execution and: 
`tf.data.TFRecordDataset(path)`

Utilisons maintenant tfdv.visualize_statistics , qui utilise Facettes pour créer une visualisation succincte de nos données de formation:

  • Notez que les caractéristiques numériques et les caractéristiques catégorielles sont visualisées séparément et que des graphiques sont affichés montrant les distributions pour chaque entité.
  • Notez que les fonctionnalités avec des valeurs manquantes ou nulles affichent un pourcentage en rouge comme indicateur visuel qu'il peut y avoir des problèmes avec des exemples dans ces fonctionnalités. Le pourcentage est le pourcentage d'exemples qui ont des valeurs manquantes ou nulles pour cette fonctionnalité.
  • Notez qu'il n'y a pas d' exemple avec des valeurs pour pickup_census_tract . C'est une opportunité pour la réduction de la dimensionnalité !
  • Essayez de cliquer sur "développer" au-dessus des graphiques pour modifier l'affichage
  • Essayez de survoler les barres des graphiques pour afficher les plages et les nombres de compartiments
  • Essayez de passer entre le journal et les échelles linéaires, et remarquez comment l'échelle logarithmique révèle beaucoup plus de détails sur la payment_type fonction catégorique
  • Essayez de sélectionner « quantiles » dans le menu « Graphique à afficher » et survolez les marqueurs pour afficher les pourcentages des quantiles
tfdv.visualize_statistics(train_stats)

Déduire un schéma

Maintenant , nous allons utiliser tfdv.infer_schema pour créer un schéma pour nos données. Un schéma définit des contraintes pour les données pertinentes pour le ML. Des exemples de contraintes incluent le type de données de chaque entité, qu'elle soit numérique ou catégorielle, ou la fréquence de sa présence dans les données. Pour les caractéristiques catégorielles, le schéma définit également le domaine - la liste des valeurs acceptables. É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.

Obtenir le bon schéma est important car le reste de notre pipeline de production s'appuiera sur le schéma généré par TFDV pour être correct. Le schéma fournit également une documentation pour les données et est donc utile lorsque différents développeurs travaillent sur les mêmes données. Utilisation Let tfdv.display_schema pour afficher le schéma inférée afin que nous puissions l' examiner.

schema = tfdv.infer_schema(statistics=train_stats)
tfdv.display_schema(schema=schema)
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_data_validation/utils/display_util.py:151: FutureWarning: Passing a negative integer is deprecated in version 1.0 and will not be supported in future version. Instead, use None to not limit the column width.
  pd.set_option('max_colwidth', -1)

Vérifier les données d'évaluation pour les erreurs

Jusqu'à présent, nous n'avons examiné que les données d'entraînement. Il est important que nos données d'évaluation soient cohérentes avec nos données d'entraînement, y compris qu'elles utilisent le même schéma. Il est également important que les données d'évaluation incluent des exemples d'à peu près les mêmes plages de valeurs pour nos caractéristiques numériques que nos données d'entraînement, de sorte que notre couverture de la surface de perte pendant l'évaluation soit à peu près la même que pendant l'entraînement. Il en est de même pour les caractéristiques catégorielles. Sinon, nous pourrions avoir des problèmes de formation qui ne sont pas identifiés lors de l'évaluation, car nous n'avons pas évalué une partie de notre surface de perte.

  • Notez que chaque fonctionnalité inclut désormais des statistiques pour les ensembles de données d'entraînement et d'évaluation.
  • Notez que les graphiques ont maintenant à la fois les ensembles de données d'entraînement et d'évaluation superposés, ce qui facilite leur comparaison.
  • Notez que les graphiques incluent désormais une vue des pourcentages, qui peut être combinée avec le journal ou les échelles linéaires par défaut.
  • Notez que la moyenne et la médiane pour trip_miles sont différentes pour la formation par rapport aux ensembles de données d'évaluation. Cela posera-t-il des problèmes ?
  • Wow, les max tips est très différent pour la formation par rapport aux ensembles de données d'évaluation. Cela posera-t-il des problèmes ?
  • Cliquez sur développer sur le graphique Caractéristiques numériques et sélectionnez l'échelle du journal. Passez en revue les trip_seconds fonction, et notez la différence dans le max. L'évaluation manquera-t-elle des parties de la surface de perte ?
# Compute stats for evaluation data
eval_stats = tfdv.generate_statistics_from_csv(data_location=EVAL_DATA)

# Compare evaluation data with training data
tfdv.visualize_statistics(lhs_statistics=eval_stats, rhs_statistics=train_stats,
                          lhs_name='EVAL_DATASET', rhs_name='TRAIN_DATASET')

Vérifier les anomalies d'évaluation

Notre ensemble de données d'évaluation correspond-il au schéma de notre ensemble de données d'entraînement ? Ceci est particulièrement important pour les caractéristiques catégorielles, où nous voulons identifier la plage de valeurs acceptables.

# Check eval data for errors by validating the eval data stats using the previously inferred schema.
anomalies = tfdv.validate_statistics(statistics=eval_stats, schema=schema)
tfdv.display_anomalies(anomalies)
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_data_validation/utils/display_util.py:186: FutureWarning: Passing a negative integer is deprecated in version 1.0 and will not be supported in future version. Instead, use None to not limit the column width.
  pd.set_option('max_colwidth', -1)

Corriger les anomalies d'évaluation dans le schéma

Oups! Il semble que nous avons des nouvelles valeurs pour l' company dans nos données d'évaluation, que nous ne disposions pas dans nos données de formation. Nous avons aussi une nouvelle valeur pour payment_type . Celles-ci doivent être considérées comme des anomalies, mais ce que nous décidons de faire à leur sujet dépend de notre connaissance du domaine des données. Si une anomalie indique vraiment une erreur de données, les données sous-jacentes doivent être corrigées. Sinon, nous pouvons simplement mettre à jour le schéma pour inclure les valeurs dans l'ensemble de données eval.

À moins que nous ne modifiions notre ensemble de données d'évaluation, nous ne pouvons pas tout réparer, mais nous pouvons corriger les choses dans le schéma que nous acceptons facilement. Cela inclut l'assouplissement de notre vision de ce qui est et ce qui n'est pas une anomalie pour des fonctionnalités particulières, ainsi que la mise à jour de notre schéma pour inclure les valeurs manquantes pour les fonctionnalités catégorielles. TFDV nous a permis de découvrir ce que nous devons corriger.

Faisons ces corrections maintenant, puis révisons une fois de plus.

# Relax the minimum fraction of values that must come from the domain for feature company.
company = tfdv.get_feature(schema, 'company')
company.distribution_constraints.min_domain_mass = 0.9

# Add new value to the domain of feature payment_type.
payment_type_domain = tfdv.get_domain(schema, 'payment_type')
payment_type_domain.value.append('Prcard')

# Validate eval stats after updating the schema 
updated_anomalies = tfdv.validate_statistics(eval_stats, schema)
tfdv.display_anomalies(updated_anomalies)

Hé, regarde ça ! Nous avons vérifié que les données de formation et d'évaluation sont désormais cohérentes ! Merci TFDV ;)

Environnements de schéma

Nous avons également séparé un ensemble de données « servant » pour cet exemple, nous devons donc le vérifier également. Par défaut, tous les ensembles de données d'un pipeline doivent utiliser le même schéma, mais il existe souvent des exceptions. Par exemple, dans l'apprentissage supervisé, nous devons inclure des étiquettes dans notre ensemble de données, mais lorsque nous servons le modèle pour l'inférence, les étiquettes ne seront pas incluses. Dans certains cas, il est nécessaire d'introduire de légères variations de schéma.

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

Par exemple, dans ce jeu de données de la tips fonctionnalité est incluse comme l'étiquette pour 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_csv(SERVING_DATA)
serving_anomalies = tfdv.validate_statistics(serving_stats, schema)

tfdv.display_anomalies(serving_anomalies)
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_data_validation/utils/display_util.py:186: FutureWarning: Passing a negative integer is deprecated in version 1.0 and will not be supported in future version. Instead, use None to not limit the column width.
  pd.set_option('max_colwidth', -1)

Nous allons traiter avec les tips ci - après illustrent. Nous avons également une valeur INT dans nos secondes de trajet, où notre schéma attendait un FLOAT. En nous faisant prendre conscience de cette différence, TFDV aide à découvrir les incohérences dans la manière dont les données sont générées pour la formation et la diffusion. Il est très facile d'ignorer de tels problèmes jusqu'à ce que les performances du modèle en souffrent, parfois de manière catastrophique. Il peut s'agir ou non d'un problème important, mais dans tous les cas, cela devrait justifier une enquête plus approfondie.

Dans ce cas, nous pouvons convertir en toute sécurité les valeurs INT en FLOAT, nous voulons donc dire à TFDV d'utiliser notre schéma pour déduire le type. Faisons-le maintenant.

options = tfdv.StatsOptions(schema=schema, infer_type_from_schema=True)
serving_stats = tfdv.generate_statistics_from_csv(SERVING_DATA, stats_options=options)
serving_anomalies = tfdv.validate_statistics(serving_stats, schema)

tfdv.display_anomalies(serving_anomalies)
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_data_validation/utils/display_util.py:186: FutureWarning: Passing a negative integer is deprecated in version 1.0 and will not be supported in future version. Instead, use None to not limit the column width.
  pd.set_option('max_colwidth', -1)

Maintenant , nous avons juste la tips caractéristique ( ce qui est notre label) montrant comme une anomalie ( « colonne supprimée »). Bien sûr, nous ne nous attendons pas à avoir des étiquettes dans nos données de diffusion, alors disons à TFDV d'ignorer cela.

# 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')

tfdv.display_anomalies(serving_anomalies_with_env)

Vérifier la dérive et l'asymétrie

En plus de vérifier si un ensemble de données est conforme aux attentes définies dans le schéma, TFDV fournit également des fonctionnalités pour détecter la dérive et l'asymétrie. TFDV effectue cette vérification en comparant les statistiques des différents ensembles de données sur la base des comparateurs de dérive/d'asymétrie spécifiés dans le schéma.

Dérive

La détection de dérive est prise en charge pour les caractéristiques catégorielles et entre des intervalles de données consécutifs (c'est-à-dire entre l'intervalle N et l'intervalle N+1), comme entre différents jours de données d'entraînement. Nous exprimons la dérive en termes de distance L-infini , et vous pouvez régler la distance de seuil de sorte que vous recevez des avertissements lorsque la dérive est plus élevé que ce qui est acceptable. La définition de la distance correcte est généralement un processus itératif nécessitant une connaissance du domaine et une expérimentation.

Fausser

TFDV peut détecter trois types différents d'asymétrie dans vos données : l'asymétrie du schéma, l'asymétrie des caractéristiques et l'asymétrie de la distribution.

Inclinaison du schéma

Un asymétrie de schéma se produit lorsque les données d'entraînement et de diffusion ne sont pas conformes au même schéma. Les données d'entraînement et de diffusion doivent adhérer au même schéma. Tout écart attendu entre les deux (comme la caractéristique d'étiquette étant uniquement présente dans les données d'entraînement mais pas dans la diffusion) doit être spécifié via le champ environnements dans le schéma.

Caractéristique asymétrique

L'asymétrie des caractéristiques se produit lorsque les valeurs des caractéristiques sur lesquelles un modèle s'entraîne sont différentes des valeurs des caractéristiques qu'il voit au moment de la diffusion. Par exemple, cela peut se produire lorsque :

  • Une source de données qui fournit certaines valeurs de caractéristiques est modifiée entre l'entraînement et le temps de service
  • Il existe une logique différente pour générer des fonctionnalités entre l'entraînement et le service. Par exemple, si vous appliquez une transformation uniquement dans l'un des deux chemins de code.

Distribution asymétrique

L'asymétrie de distribution se produit lorsque la distribution de l'ensemble de données d'apprentissage est significativement différente de la distribution de l'ensemble de données de diffusion. L'une des principales causes de l'asymétrie de la distribution est l'utilisation d'un code différent ou de différentes sources de données pour générer l'ensemble de données d'apprentissage. Une autre raison est un mécanisme d'échantillonnage défectueux qui choisit un sous-échantillon non représentatif des données de diffusion sur lesquelles s'entraîner.

# Add skew comparator for 'payment_type' feature.
payment_type = tfdv.get_feature(schema, 'payment_type')
payment_type.skew_comparator.infinity_norm.threshold = 0.01

# Add drift comparator for 'company' feature.
company=tfdv.get_feature(schema, 'company')
company.drift_comparator.infinity_norm.threshold = 0.001

skew_anomalies = tfdv.validate_statistics(train_stats, schema,
                                          previous_statistics=eval_stats,
                                          serving_statistics=serving_stats)

tfdv.display_anomalies(skew_anomalies)
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_data_validation/utils/display_util.py:186: FutureWarning: Passing a negative integer is deprecated in version 1.0 and will not be supported in future version. Instead, use None to not limit the column width.
  pd.set_option('max_colwidth', -1)

Dans cet exemple, nous voyons une certaine dérive, mais elle est bien en deçà du seuil que nous avons défini.

Geler le schéma

Maintenant que le schéma a été examiné et organisé, nous allons le stocker dans un fichier pour refléter son état "gelé".

from tensorflow.python.lib.io import file_io
from google.protobuf import text_format

file_io.recursive_create_dir(OUTPUT_DIR)
schema_file = os.path.join(OUTPUT_DIR, 'schema.pbtxt')
tfdv.write_schema_text(schema, schema_file)

!cat {schema_file}
feature {
  name: "payment_type"
  type: BYTES
  domain: "payment_type"
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  skew_comparator {
    infinity_norm {
      threshold: 0.01
    }
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "company"
  value_count {
    min: 1
    max: 1
  }
  type: BYTES
  domain: "company"
  presence {
    min_count: 1
  }
  distribution_constraints {
    min_domain_mass: 0.9
  }
  drift_comparator {
    infinity_norm {
      threshold: 0.001
    }
  }
}
feature {
  name: "pickup_community_area"
  type: INT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "fare"
  type: FLOAT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "trip_start_month"
  type: INT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "trip_start_hour"
  type: INT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "trip_start_day"
  type: INT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "trip_start_timestamp"
  type: INT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "pickup_latitude"
  type: FLOAT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "pickup_longitude"
  type: FLOAT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "dropoff_latitude"
  value_count {
    min: 1
    max: 1
  }
  type: FLOAT
  presence {
    min_count: 1
  }
}
feature {
  name: "dropoff_longitude"
  value_count {
    min: 1
    max: 1
  }
  type: FLOAT
  presence {
    min_count: 1
  }
}
feature {
  name: "trip_miles"
  type: FLOAT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "pickup_census_tract"
  type: BYTES
  presence {
    min_count: 0
  }
}
feature {
  name: "dropoff_census_tract"
  value_count {
    min: 1
    max: 1
  }
  type: INT
  presence {
    min_count: 1
  }
}
feature {
  name: "trip_seconds"
  type: INT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "dropoff_community_area"
  value_count {
    min: 1
    max: 1
  }
  type: INT
  presence {
    min_count: 1
  }
}
feature {
  name: "tips"
  type: FLOAT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  not_in_environment: "SERVING"
  shape {
    dim {
      size: 1
    }
  }
}
string_domain {
  name: "payment_type"
  value: "Cash"
  value: "Credit Card"
  value: "Dispute"
  value: "No Charge"
  value: "Pcard"
  value: "Unknown"
  value: "Prcard"
}
string_domain {
  name: "company"
  value: "0118 - 42111 Godfrey S.Awir"
  value: "0694 - 59280 Chinesco Trans Inc"
  value: "1085 - 72312 N and W Cab Co"
  value: "2733 - 74600 Benny Jona"
  value: "2809 - 95474 C & D Cab Co Inc."
  value: "3011 - 66308 JBL Cab Inc."
  value: "3152 - 97284 Crystal Abernathy"
  value: "3201 - C&D Cab Co Inc"
  value: "3201 - CID Cab Co Inc"
  value: "3253 - 91138 Gaither Cab Co."
  value: "3385 - 23210 Eman Cab"
  value: "3623 - 72222 Arrington Enterprises"
  value: "3897 - Ilie Malec"
  value: "4053 - Adwar H. Nikola"
  value: "4197 - 41842 Royal Star"
  value: "4615 - 83503 Tyrone Henderson"
  value: "4615 - Tyrone Henderson"
  value: "4623 - Jay Kim"
  value: "5006 - 39261 Salifu Bawa"
  value: "5006 - Salifu Bawa"
  value: "5074 - 54002 Ahzmi Inc"
  value: "5074 - Ahzmi Inc"
  value: "5129 - 87128"
  value: "5129 - 98755 Mengisti Taxi"
  value: "5129 - Mengisti Taxi"
  value: "5724 - KYVI Cab Inc"
  value: "585 - Valley Cab Co"
  value: "5864 - 73614 Thomas Owusu"
  value: "5864 - Thomas Owusu"
  value: "5874 - 73628 Sergey Cab Corp."
  value: "5997 - 65283 AW Services Inc."
  value: "5997 - AW Services Inc."
  value: "6488 - 83287 Zuha Taxi"
  value: "6743 - Luhak Corp"
  value: "Blue Ribbon Taxi Association Inc."
  value: "C & D Cab Co Inc"
  value: "Chicago Elite Cab Corp."
  value: "Chicago Elite Cab Corp. (Chicago Carriag"
  value: "Chicago Medallion Leasing INC"
  value: "Chicago Medallion Management"
  value: "Choice Taxi Association"
  value: "Dispatch Taxi Affiliation"
  value: "KOAM Taxi Association"
  value: "Northwest Management LLC"
  value: "Taxi Affiliation Services"
  value: "Top Cab Affiliation"
}
default_environment: "TRAINING"
default_environment: "SERVING"

Quand utiliser TFDV

Il est facile de penser que TFDV ne s'applique qu'au début de votre pipeline de formation, comme nous l'avons fait ici, mais en fait, il a de nombreuses utilisations. En voici quelques autres :

  • Valider les nouvelles données pour l'inférence afin de s'assurer que nous n'avons pas soudainement commencé à recevoir de mauvaises fonctionnalités
  • Valider de nouvelles données pour l'inférence pour s'assurer que notre modèle a été formé sur cette partie de la surface de décision
  • Nos données après la validation que nous avons transformé et fini ingénierie fonctionnalité (probablement à l' aide tensorflow Transform ) pour nous assurer que nous n'avons pas fait quelque chose de mal