Pomoc chronić Wielkiej Rafy Koralowej z TensorFlow na Kaggle Dołącz Wyzwanie

Zacznij korzystać z walidacji danych Tensorflow

Tensorflow Data Validation (TFDV) może analizować dane uczące i obsługujące, aby:

Podstawowy interfejs API obsługuje każdy element funkcjonalności, z wygodnymi metodami, które bazują na wierzchu i można je wywoływać w kontekście notatników.

Obliczanie opisowej statystyki danych

TFDV może obliczyć opisowych statystyk , które zapewniają szybki przegląd danych pod względem cech, które są obecne i kształty ich rozkładów wartości. Narzędzia takie jak Facets Przegląd może dostarczyć zwięzłą wizualizację tych statystyk dla łatwego przeglądania.

Na przykład załóżmy, że path wskazuje na plik w TFRecord formacie (który przechowuje rekordy typu tensorflow.Example ). Poniższy fragment ilustruje obliczanie statystyk przy użyciu TFDV:

    stats = tfdv.generate_statistics_from_tfrecord(data_location=path)

Zwrócona wartość jest DatasetFeatureStatisticsList bufor protokół. Przykład notebook zawiera wizualizację danych statystycznych z wykorzystaniem Facets Przegląd :

    tfdv.visualize_statistics(stats)

Zrzut ekranu wizualizacji statystyk

Poprzedni przykład zakłada, że dane są przechowywane w TFRecord pliku. TFDV obsługuje również format wejściowy CSV, z możliwością rozszerzenia na inne popularne formaty. Można znaleźć dostępne dekodery danych tutaj . Ponadto TFDV zapewnia tfdv.generate_statistics_from_dataframe funkcję użytkową dla użytkowników, z danych zawartych w pamięci przedstawiony jako pand DataFrame.

Oprócz obliczania domyślnego zestawu statystyk danych, TFDV może również obliczać statystyki dla domen semantycznych (np. obrazy, tekst). Aby umożliwić obliczenie semantycznych statystyki domen zdać tfdv.StatsOptions obiekt z enable_semantic_domain_stats ustawiona na wartość true, aby tfdv.generate_statistics_from_tfrecord .

Działa w Google Cloud

Wewnętrznie TFDV wykorzystuje Apache belki ramy przetwarzanie jest danych równolegle do skalowania obliczeń statystycznych na dużych zbiorów danych. W przypadku aplikacji, które chcą integrować się głębiej z TFDV (np załączyć generowanie statystyk na końcu rurociągu dane generacji, generować statystyki dla danych w formacie niestandardowym ), API naraża także Beam PTransform do generowania statystyk.

Aby uruchomić TFDV w Google Cloud, należy pobrać plik koła TFDV i przekazać go pracownikom Dataflow. Pobierz plik koła do bieżącego katalogu w następujący sposób:

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

Poniższy fragment przedstawia przykładowe użycie TFDV w 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)

W tym przypadku, generowane statystyki proto jest przechowywany w pliku TFRecord pisemnej GCS_STATS_OUTPUT_PATH .

UWAGA Przy wywołaniu którekolwiek z tfdv.generate_statistics_... funkcji (np tfdv.generate_statistics_from_tfrecord ) w Google Cloud, należy zapewnić output_path . Określenie Brak może spowodować błąd.

Wnioskowanie schematu na podstawie danych

Schemat opisuje oczekiwane właściwości danych. Niektóre z tych właściwości to:

  • jakie funkcje mają być obecne?
  • ich typ
  • liczba wartości funkcji w każdym przykładzie
  • obecność każdej funkcji we wszystkich przykładach
  • oczekiwane domeny funkcji.

W skrócie, schemat opisuje oczekiwania dotyczące „poprawnych” danych, a zatem może służyć do wykrywania błędów w danych (opisanych poniżej). Ponadto, ten sam schemat można wykorzystać do utworzenia Tensorflow Transform dla transformacji danych. Należy zauważyć, że oczekuje się, że schemat będzie dość statyczny, np. kilka zestawów danych może być zgodnych z tym samym schematem, podczas gdy statystyki (opisane powyżej) mogą się różnić w zależności od zestawu danych.

Ponieważ pisanie schematu może być żmudnym zadaniem, szczególnie w przypadku zestawów danych z wieloma funkcjami, TFDV zapewnia metodę generowania początkowej wersji schematu na podstawie statystyk opisowych:

    schema = tfdv.infer_schema(stats)

Ogólnie rzecz biorąc, TFDV wykorzystuje konserwatywną heurystykę, aby wywnioskować stabilne właściwości danych ze statystyk, aby uniknąć nadmiernego dopasowania schematu do określonego zestawu danych. Zaleca się, aby przejrzeć wywieść schematu i udoskonalić go, ile potrzeba, aby uchwycić żadnej wiedzy na temat domeny danych heurystyki TFDV za mógłby przegapić.

Domyślnie tfdv.infer_schema wyprowadza Kształt każdej wymaganej funkcji, jeśli value_count.min równa value_count.max dla funkcji. Ustaw infer_feature_shape argumentu false aby wyłączyć kształt wnioskowania.

Sam schematu jest przechowywana jako bufor protokołu Schematu a zatem może być na bieżąco / zmodyfikowane za pomocą standardowego protokołu API-bufora. TFDV zapewnia również kilka metod narzędziowych , aby te aktualizacje łatwiejsze. Na przykład, załóżmy, że schemat zawiera następującą strofę do opisania wymaganego ciąg fabularny payment_type które ma jedną wartość:

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

Aby zaznaczyć, że cecha powinna być wypełniona w co najmniej 50% przykładów:

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

Przykład notebook zawiera prostą wizualizację schematu postaci tabeli, wymieniając każdą funkcję i jego główne cechy jako zakodowane w schemacie.

Zrzut ekranu wizualizacji schematu

Sprawdzanie danych pod kątem błędów

Biorąc pod uwagę schemat, możliwe jest, aby sprawdzić, czy zbiorze danych jest zgodny z oczekiwaniami określonymi w schemacie, czy istnieją jakiekolwiek anomalie danych . Możesz sprawdzić swoje dane pod kątem błędów (a) zbiorczo w całym zbiorze danych, dopasowując statystyki zbioru danych do schematu lub (b) sprawdzając błędy w poszczególnych przykładach.

Dopasowywanie statystyk zbioru danych do schematu

Aby sprawdzić błędy w agregacie, TFDV dopasowuje statystyki zestawu danych do schematu i zaznacza wszelkie rozbieżności. Na przykład:

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

Wynikiem tego jest wystąpienie anomalii buforze protokołu i opisuje wszelkie błędy w których statystyki nie zgadzają się ze schematem. Na przykład załóżmy, że dane na other_path zawiera przykłady z wartościami dla funkcji payment_type spoza domeny określonej w schemacie.

Powoduje to anomalię

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

wskazując, że wartość spoza domeny została znaleziona w statystykach w < 1% wartości cech.

Jeśli było to oczekiwane, schemat można zaktualizować w następujący sposób:

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

Jeśli anomalia rzeczywiście wskazuje na błąd danych, należy naprawić dane bazowe przed użyciem ich do uczenia.

Poszczególne typy anomalii, które mogą być wykrywane przez moduł są wymienione tutaj .

Przykład notebook zawiera prostą wizualizację anomalii w postaci tabeli, wymieniając cechy gdzie są wykryte błędy i krótki opis każdego błędu.

Zrzut ekranu anomalii

Sprawdzanie błędów na podstawie przykładu

TFDV zapewnia również opcję sprawdzania poprawności danych na podstawie przykładu, zamiast porównywania statystyk dotyczących całego zestawu danych ze schematem. TFDV udostępnia funkcje do sprawdzania poprawności danych na podstawie przykładu, a następnie generowania statystyk podsumowujących dla znalezionych nietypowych przykładów. Na przykład:

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

W anomalous_example_stats że validate_examples_in_tfrecord powraca jest DatasetFeatureStatisticsList bufor protokół, w którym każdy zestaw danych składa się z szeregu przykładach, które wykazują szczególną anomalii. Możesz użyć tego do określenia liczby przykładów w zestawie danych, które wykazują daną anomalię, oraz charakterystyki tych przykładów.

Środowiska schematu

Domyślnie walidacje zakładają, że wszystkie zestawy danych w potoku są zgodne z jednym schematem. W niektórych przypadkach konieczne jest wprowadzenie niewielkich zmian w schemacie, na przykład funkcje używane jako etykiety są wymagane podczas uczenia (i powinny zostać zweryfikowane), ale brakuje ich podczas udostępniania.

Środowisk może być zastosowane do ekspresji takich wymagań. W szczególności funkcje w schemacie mogą być skojarzone z zestawem środowisk przy użyciu środowiska default_environment, in_environment i not_in_environment.

Na przykład, jeśli funkcja wskazówek jest używana jako etykieta w szkoleniu, ale brakuje w danych służących. Bez określonego środowiska pojawi się jako anomalia.

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

Zrzut ekranu przedstawiający anomalie w obsłudze

Aby to naprawić, musimy ustawić domyślne środowisko dla wszystkich funkcji na „TRENING” i „SERWOWANIE” oraz wykluczyć funkcję „wskazówki” ze środowiska OBSŁUGIWANIA.

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

Sprawdzanie pochylenia i dryfu danych

Oprócz sprawdzania, czy zbiór danych jest zgodny z oczekiwaniami określonymi w schemacie, TFDV zapewnia również funkcje do wykrywania:

  • przechylenie między danymi treningowymi a danymi serwowania
  • dryfować między różnymi dniami danych treningowych

TFDV przeprowadza to sprawdzenie, porównując statystyki różnych zestawów danych na podstawie komparatorów dryfu/skosu określonych w schemacie. Na przykład, aby sprawdzić, czy występuje przekrzywienie między funkcją „payment_type” w zbiorze danych trenowania i udostępniania:

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

UWAGA Aby wykryć pochylać do funkcji numerycznych określ jensen_shannon_divergence próg zamiast jego infinity_norm progu w skew_comparator .

To samo z sprawdzenie, czy zestaw danych zgodne z oczekiwaniami określonymi w schemacie, wynik jest również wystąpienie anomalii buforze protokołu i opisuje każdy skośna pomiędzy szkolenia i zbiorów danych służących. Na przykład, załóżmy, że dane służące zawiera znacznie więcej przykładów z funkcją payement_type o wartość Cash , to wytwarza pochylać anomalię

   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

Jeśli anomalia rzeczywiście wskazuje na przekrzywienie między danymi uczącymi i obsługującymi, konieczne jest dalsze badanie, ponieważ może to mieć bezpośredni wpływ na wydajność modelu.

Przykład notebook zawiera prosty przykład sprawdzanie skośnych oparte anomalii.

Wykrywanie dryfu między różnymi dniami danych treningowych można przeprowadzić w podobny sposób

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

UWAGA Aby wykryć pochylać do funkcji numerycznych określ jensen_shannon_divergence próg zamiast jego infinity_norm progu w drift_comparator .

Pisanie niestandardowego łącznika danych

Do obliczania danych statystycznych, TFDV oferuje kilka wygodnych metod obsługi danych wejściowych w różnych formatach (np TFRecord z tf.train.Example , CSV, itp.) Jeśli Twojego formatu danych nie ma na tej liście, musisz napisać niestandardowy łącznik danych do odczytywania danych wejściowych i połączyć go z podstawowym interfejsem API TFDV w celu obliczania statystyk danych.

TFDV rdzeń API do obliczania statystyki danych jest Belka PTransform który wymaga PCollection porcji przykładów wejściowych (partia przykładów wejściowych jest reprezentowany jako Strzałka RecordBatch) i wyprowadza PCollection zawierający pojedynczy DatasetFeatureStatisticsList bufor protokołu.

Kiedy już wdrożone złącze danych niestandardowych że partie twoje przykłady wprowadzania w strzałką RecordBatch, trzeba połączyć go z tfdv.GenerateStatistics API do obliczania statystyk z danymi. Weź TFRecord z tf.train.Example „s na przykład. tfx_bsl zapewnia TFExampleRecord złącze danych, a poniżej jest przykładem, jak połączyć go z tfdv.GenerateStatistics API.

import tensorflow_data_validation as tfdv
from tfx_bsl.public import tfxio
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 and decode the data with tfx_bsl.
    | 'TFXIORead' >> (
          tfxio.TFExampleRecord(
              file_pattern=[DATA_LOCATION],
              telemetry_descriptors=['my', 'tfdv']).BeamSource())
    # 2. Invoke TFDV `GenerateStatistics` API to compute the data statistics.
    | 'GenerateStatistics' >> tfdv.GenerateStatistics()
    # 3. Materialize the generated data statistics.
    | 'WriteStatsOutput' >> WriteStatisticsToTFRecord(OUTPUT_LOCATION))

Obliczanie statystyk na wycinkach danych

TFDV można skonfigurować do obliczania statystyk na wycinkach danych. Odcinanie można włączyć poprzez zapewnienie funkcji krojenie, które biorą w strzałką RecordBatch i wyjście sekwencję krotek postaci (slice key, record batch) . TFDV zapewnia łatwy sposób generować wartość funkcji opartych funkcji krojenie , które mogą być świadczone w ramach tfdv.StatsOptions podczas obliczania statystyk.

Podczas krojenia jest włączona, wyjście DatasetFeatureStatisticsList proto zawiera wiele DatasetFeatureStatistics Protos, po jednym dla każdego segmentu. Każdy kawałek jest identyfikowany przez unikalną nazwę, która jest ustawiona jako nazwa zestawu danych w proto DatasetFeatureStatistics . Domyślnie TFDV oblicza statystyki dla całego zestawu danych oprócz skonfigurowanych wycinków.

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])