Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

Analiza modelu TensorFlow

Przykład kluczowego składnika TensorFlow Extended (TFX)

TensorFlow Model Analysis (TFMA) to biblioteka do przeprowadzania oceny modelu na różnych wycinkach danych. TFMA wykonuje obliczenia w sposób rozproszony na dużych ilościach danych przy użyciu Apache Beam .

Ten przykładowy notatnik colab ilustruje, w jaki sposób można użyć TFMA do badania i wizualizacji wydajności modelu w odniesieniu do charakterystyk zestawu danych. Użyjemy modelu, który trenowaliśmy wcześniej, a teraz możesz bawić się wynikami! Trenowany przez nas model był przeznaczony dla przykładu Chicago Taxi , który korzysta z zestawu danych Taxi Trips wydanego przez miasto Chicago. Poznaj pełny zestaw danych w interfejsie użytkownika BigQuery .

Jako twórca modeli i programista zastanów się, w jaki sposób te dane są wykorzystywane oraz jakie potencjalne korzyści i szkody mogą spowodować przewidywania modelu. Taki model mógłby wzmocnić społeczne uprzedzenia i dysproporcje. Czy funkcja ma związek z problemem, który chcesz rozwiązać, czy też wprowadzi błąd? Aby uzyskać więcej informacji, przeczytaj o uczciwości ML .

Kolumny w zbiorze danych to:

pickup_community_area opłata trip_start_month
trip_start_hour trip_start_day trip_start_timestamp
pickup_latitude pickup_longitude dropoff_latitude
dropoff_longitude trip_miles pickup_census_tract
dropoff_census_tract typ płatności firma
trip_seconds dropoff_community_area wskazówki

Zainstaluj rozszerzenia Jupyter

jupyter nbextension enable --py widgetsnbextension --sys-prefix 
jupyter nbextension install --py --symlink tensorflow_model_analysis --sys-prefix 
jupyter nbextension enable --py tensorflow_model_analysis --sys-prefix 

Zainstaluj TensorFlow Model Analysis (TFMA)

Spowoduje to ściągnięcie wszystkich zależności i zajmie minutę.

Uwaga: aby upewnić się, że wszystkie zależności są poprawnie zainstalowane, może być konieczne wielokrotne ponowne uruchomienie tego kroku instalacji, zanim nie wystąpią żadne błędy.

# This setup was tested with TF 2.3 and TFMA 0.24 (using colab), but it should
# also work with the latest release.
import sys

# Confirm that we're using Python 3
assert sys.version_info.major==3, 'This notebook must be run using Python 3.'

print('Installing TensorFlow')
import tensorflow as tf
print('TF version: {}'.format(tf.__version__))

print('Installing Tensorflow Model Analysis and Dependencies')
!pip install -q tensorflow_model_analysis
import apache_beam as beam
print('Beam version: {}'.format(beam.__version__))
import tensorflow_model_analysis as tfma
print('TFMA version: {}'.format(tfma.__version__))
Installing TensorFlow
TF version: 2.3.1
Installing Tensorflow Model Analysis and Dependencies
ERROR: After October 2020 you may experience errors when installing or updating packages. This is because pip will change the way that it resolves dependency conflicts.

We recommend you use --use-feature=2020-resolver to test your packages with the new resolver before it becomes the default.

google-api-python-client 1.12.3 requires httplib2<1dev,>=0.15.0, but you'll have httplib2 0.9.2 which is incompatible.
Beam version: 2.24.0
TFMA version: 0.24.3

Załaduj pliki

Pobierzemy plik tar, który ma wszystko, czego potrzebujemy. To obejmuje:

  • Zestawy danych dotyczących szkolenia i oceny
  • Schemat danych
  • Uczenie i obsługa zapisanych modeli (keras i estymator) oraz ewaluacja zapisanych modeli (estymator).
# Download the tar file from GCP and extract it
import io, os, tempfile
TAR_NAME = 'saved_models-2.2'
BASE_DIR = tempfile.mkdtemp()
DATA_DIR = os.path.join(BASE_DIR, TAR_NAME, 'data')
MODELS_DIR = os.path.join(BASE_DIR, TAR_NAME, 'models')
SCHEMA = os.path.join(BASE_DIR, TAR_NAME, 'schema.pbtxt')
OUTPUT_DIR = os.path.join(BASE_DIR, 'output')

!curl -O https://storage.googleapis.com/artifacts.tfx-oss-public.appspot.com/datasets/{TAR_NAME}.tar
!tar xf {TAR_NAME}.tar
!mv {TAR_NAME} {BASE_DIR}
!rm {TAR_NAME}.tar

print("Here's what we downloaded:")
!ls -R {BASE_DIR}
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 6800k  100 6800k    0     0  25.4M      0 --:--:-- --:--:-- --:--:-- 25.3M
Here's what we downloaded:
/tmp/tmpj6t03cp6:
saved_models-2.2

/tmp/tmpj6t03cp6/saved_models-2.2:
data  models  schema.pbtxt

/tmp/tmpj6t03cp6/saved_models-2.2/data:
eval  train

/tmp/tmpj6t03cp6/saved_models-2.2/data/eval:
data.csv

/tmp/tmpj6t03cp6/saved_models-2.2/data/train:
data.csv

/tmp/tmpj6t03cp6/saved_models-2.2/models:
estimator  keras

/tmp/tmpj6t03cp6/saved_models-2.2/models/estimator:
eval_model_dir  serving_model_dir

/tmp/tmpj6t03cp6/saved_models-2.2/models/estimator/eval_model_dir:
1591221811

/tmp/tmpj6t03cp6/saved_models-2.2/models/estimator/eval_model_dir/1591221811:
saved_model.pb  tmp.pbtxt  variables

/tmp/tmpj6t03cp6/saved_models-2.2/models/estimator/eval_model_dir/1591221811/variables:
variables.data-00000-of-00001  variables.index

/tmp/tmpj6t03cp6/saved_models-2.2/models/estimator/serving_model_dir:
checkpoint
eval_chicago-taxi-eval
events.out.tfevents.1591221780.my-pipeline-b57vp-237544850
export
graph.pbtxt
model.ckpt-100.data-00000-of-00001
model.ckpt-100.index
model.ckpt-100.meta

/tmp/tmpj6t03cp6/saved_models-2.2/models/estimator/serving_model_dir/eval_chicago-taxi-eval:
events.out.tfevents.1591221799.my-pipeline-b57vp-237544850

/tmp/tmpj6t03cp6/saved_models-2.2/models/estimator/serving_model_dir/export:
chicago-taxi

/tmp/tmpj6t03cp6/saved_models-2.2/models/estimator/serving_model_dir/export/chicago-taxi:
1591221801

/tmp/tmpj6t03cp6/saved_models-2.2/models/estimator/serving_model_dir/export/chicago-taxi/1591221801:
saved_model.pb  variables

/tmp/tmpj6t03cp6/saved_models-2.2/models/estimator/serving_model_dir/export/chicago-taxi/1591221801/variables:
variables.data-00000-of-00001  variables.index

/tmp/tmpj6t03cp6/saved_models-2.2/models/keras:
0  1  2

/tmp/tmpj6t03cp6/saved_models-2.2/models/keras/0:
saved_model.pb  variables

/tmp/tmpj6t03cp6/saved_models-2.2/models/keras/0/variables:
variables.data-00000-of-00001  variables.index

/tmp/tmpj6t03cp6/saved_models-2.2/models/keras/1:
saved_model.pb  variables

/tmp/tmpj6t03cp6/saved_models-2.2/models/keras/1/variables:
variables.data-00000-of-00001  variables.index

/tmp/tmpj6t03cp6/saved_models-2.2/models/keras/2:
saved_model.pb  variables

/tmp/tmpj6t03cp6/saved_models-2.2/models/keras/2/variables:
variables.data-00000-of-00001  variables.index

Przeanalizuj schemat

Wśród rzeczy, które pobraliśmy, był schemat naszych danych utworzony przez TensorFlow Data Validation . Przeanalizujmy to teraz, abyśmy mogli go używać z TFMA.

import tensorflow as tf
from google.protobuf import text_format
from tensorflow.python.lib.io import file_io
from tensorflow_metadata.proto.v0 import schema_pb2
from tensorflow.core.example import example_pb2

schema = schema_pb2.Schema()
contents = file_io.read_file_to_string(SCHEMA)
schema = text_format.Parse(contents, schema)

Użyj schematu, aby utworzyć TFRecords

Musimy dać TFMA dostęp do naszego zbioru danych, więc stwórzmy plik TFRecords. Możemy użyć naszego schematu, aby go utworzyć, ponieważ daje nam on właściwy typ dla każdej funkcji.

import csv

datafile = os.path.join(DATA_DIR, 'eval', 'data.csv')
reader = csv.DictReader(open(datafile, 'r'))
examples = []
for line in reader:
  example = example_pb2.Example()
  for feature in schema.feature:
    key = feature.name
    if feature.type == schema_pb2.FLOAT:
      example.features.feature[key].float_list.value[:] = (
          [float(line[key])] if len(line[key]) > 0 else [])
    elif feature.type == schema_pb2.INT:
      example.features.feature[key].int64_list.value[:] = (
          [int(line[key])] if len(line[key]) > 0 else [])
    elif feature.type == schema_pb2.BYTES:
      example.features.feature[key].bytes_list.value[:] = (
          [line[key].encode('utf8')] if len(line[key]) > 0 else [])
  # Add a new column 'big_tipper' that indicates if tips was > 20% of the fare. 
  # TODO(b/157064428): Remove after label transformation is supported for Keras.
  big_tipper = float(line['tips']) > float(line['fare']) * 0.2
  example.features.feature['big_tipper'].float_list.value[:] = [big_tipper]
  examples.append(example)

tfrecord_file = os.path.join(BASE_DIR, 'train_data.rio')
with tf.io.TFRecordWriter(tfrecord_file) as writer:
  for example in examples:
    writer.write(example.SerializeToString())

!ls {tfrecord_file}
/tmp/tmpj6t03cp6/train_data.rio

Skonfiguruj i uruchom TFMA

TFMA obsługuje wiele różnych typów modeli, w tym modele TF keras, modele oparte na generycznych API podpisów TF2, a także modele oparte na estymatorze TF. Przewodnik get_started zawiera pełną listę obsługiwanych typów modeli i wszelkich ograniczeń. W tym przykładzie pokażemy, jak skonfigurować model oparty na keras, a także model oparty na estymatorze, który został zapisany jako EvalSavedModel . Zobacz często zadawane pytania, aby zapoznać się z przykładami innych konfiguracji.

TFMA zapewnia obsługę obliczania metryk, które były używane w czasie uczenia (tj. Metryki wbudowane), a także metryki zdefiniowane po zapisaniu modelu jako część ustawień konfiguracyjnych TFMA. W przypadku naszej konfiguracji keras zademonstrujemy ręczne dodawanie naszych metryk i wykresów w ramach naszej konfiguracji (zobacz przewodnik dotyczący metryk, aby uzyskać informacje na temat obsługiwanych metryk i wykresów). Do konfiguracji estymatora użyjemy wbudowanych metryk, które zostały zapisane z modelem. Nasze konfiguracje obejmują również szereg specyfikacji krojenia, które są omówione bardziej szczegółowo w kolejnych sekcjach.

Po utworzeniu tfma.EvalConfig i tfma.EvalSharedModel możemy następnie uruchomić TFMA za pomocą tfma.run_model_analysis . Spowoduje to utworzenie tfma.EvalResult którego możemy później użyć do renderowania naszych metryk i wykresów.

Keras

import tensorflow_model_analysis as tfma

# Setup tfma.EvalConfig settings
keras_eval_config = text_format.Parse("""
  ## Model information
  model_specs {
    # For keras (and serving models) we need to add a `label_key`.
    label_key: "big_tipper"
  }

  ## Post training metric information. These will be merged with any built-in
  ## metrics from training.
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    metrics { class_name: "BinaryAccuracy" }
    metrics { class_name: "BinaryCrossentropy" }
    metrics { class_name: "AUC" }
    metrics { class_name: "AUCPrecisionRecall" }
    metrics { class_name: "Precision" }
    metrics { class_name: "Recall" }
    metrics { class_name: "MeanLabel" }
    metrics { class_name: "MeanPrediction" }
    metrics { class_name: "Calibration" }
    metrics { class_name: "CalibrationPlot" }
    metrics { class_name: "ConfusionMatrixPlot" }
    # ... add additional metrics and plots ...
  }

  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["trip_start_hour"]
  }
  slicing_specs {
    feature_keys: ["trip_start_day"]
  }
  slicing_specs {
    feature_values: {
      key: "trip_start_month"
      value: "1"
    }
  }
  slicing_specs {
    feature_keys: ["trip_start_hour", "trip_start_day"]
  }
""", tfma.EvalConfig())

# Create a tfma.EvalSharedModel that points at our keras model.
keras_model_path = os.path.join(MODELS_DIR, 'keras', '2')
keras_eval_shared_model = tfma.default_eval_shared_model(
    eval_saved_model_path=keras_model_path,
    eval_config=keras_eval_config)

keras_output_path = os.path.join(OUTPUT_DIR, 'keras')

# Run TFMA
keras_eval_result = tfma.run_model_analysis(
    eval_shared_model=keras_eval_shared_model,
    eval_config=keras_eval_config,
    data_location=tfrecord_file,
    output_path=keras_output_path)
WARNING:absl:Tensorflow version (2.3.1) found. Note that TFMA support for TF 2.0 is currently in beta
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_model_analysis/writers/metrics_plots_and_validations_writer.py:70: 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_model_analysis/writers/metrics_plots_and_validations_writer.py:70: 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)`

Taksator

import tensorflow_model_analysis as tfma

# Setup tfma.EvalConfig settings
estimator_eval_config = text_format.Parse("""
  ## Model information
  model_specs {
    # To use EvalSavedModel set `signature_name` to "eval".
    signature_name: "eval"
  }

  ## Post training metric information. These will be merged with any built-in
  ## metrics from training.
  metrics_specs {
    metrics { class_name: "ConfusionMatrixPlot" }
    # ... add additional metrics and plots ...
  }

  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["trip_start_hour"]
  }
  slicing_specs {
    feature_keys: ["trip_start_day"]
  }
  slicing_specs {
    feature_values: {
      key: "trip_start_month"
      value: "1"
    }
  }
  slicing_specs {
    feature_keys: ["trip_start_hour", "trip_start_day"]
  }
""", tfma.EvalConfig())

# Create a tfma.EvalSharedModel that points at our eval saved model.
estimator_base_model_path = os.path.join(
    MODELS_DIR, 'estimator', 'eval_model_dir')
estimator_model_path = os.path.join(
    estimator_base_model_path, os.listdir(estimator_base_model_path)[0])
estimator_eval_shared_model = tfma.default_eval_shared_model(
    eval_saved_model_path=estimator_model_path,
    eval_config=estimator_eval_config)

estimator_output_path = os.path.join(OUTPUT_DIR, 'estimator')

# Run TFMA
estimator_eval_result = tfma.run_model_analysis(
    eval_shared_model=estimator_eval_shared_model,
    eval_config=estimator_eval_config,
    data_location=tfrecord_file,
    output_path=estimator_output_path)
WARNING:absl:Tensorflow version (2.3.1) found. Note that TFMA support for TF 2.0 is currently in beta

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_model_analysis/eval_saved_model/load.py:169: load (from tensorflow.python.saved_model.loader_impl) is deprecated and will be removed in a future version.
Instructions for updating:
This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.loader.load or tf.compat.v1.saved_model.load. There will be a new function for importing SavedModels in Tensorflow 2.0.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_model_analysis/eval_saved_model/load.py:169: load (from tensorflow.python.saved_model.loader_impl) is deprecated and will be removed in a future version.
Instructions for updating:
This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.loader.load or tf.compat.v1.saved_model.load. There will be a new function for importing SavedModels in Tensorflow 2.0.

INFO:tensorflow:Restoring parameters from /tmp/tmpj6t03cp6/saved_models-2.2/models/estimator/eval_model_dir/1591221811/variables/variables

INFO:tensorflow:Restoring parameters from /tmp/tmpj6t03cp6/saved_models-2.2/models/estimator/eval_model_dir/1591221811/variables/variables

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_model_analysis/eval_saved_model/graph_ref.py:189: get_tensor_from_tensor_info (from tensorflow.python.saved_model.utils_impl) is deprecated and will be removed in a future version.
Instructions for updating:
This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.utils.get_tensor_from_tensor_info or tf.compat.v1.saved_model.get_tensor_from_tensor_info.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_model_analysis/eval_saved_model/graph_ref.py:189: get_tensor_from_tensor_info (from tensorflow.python.saved_model.utils_impl) is deprecated and will be removed in a future version.
Instructions for updating:
This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.utils.get_tensor_from_tensor_info or tf.compat.v1.saved_model.get_tensor_from_tensor_info.

Wizualizacja metryk i wykresów

Teraz, gdy przeprowadziliśmy ocenę, przyjrzyjmy się naszym wizualizacjom przy użyciu TFMA. W poniższych przykładach zwizualizujemy wyniki przeprowadzania oceny w modelu keras. Aby wyświetlić model oparty na estymatorze, zaktualizuj eval_result aby wskazywał na naszą zmienną estimator_eval_result .

eval_result = keras_eval_result
# eval_result = estimator_eval_result

Wskaźniki renderowania

Aby wyświetlić metryki, użyj tfma.view.render_slicing_metrics

Domyślnie widoki będą wyświetlać wycinek Overall . Aby wyświetlić konkretny wycinek, możesz użyć nazwy kolumny (ustawiając slicing_column ) lub podać tfma.SlicingSpec .

Wizualizacja metryk obsługuje następujące interakcje:

  • Kliknij i przeciągnij, aby przesunąć
  • Przewiń, aby powiększyć
  • Kliknij prawym przyciskiem myszy, aby zresetować widok
  • Najedź kursorem na żądany punkt danych, aby zobaczyć więcej szczegółów.
  • Wybierz jeden z czterech różnych typów widoków, korzystając z opcji u dołu.

Na przykład slicing_column aby spojrzeć na funkcję trip_start_hour z naszych poprzednich slicing_specs .

tfma.view.render_slicing_metrics(eval_result, slicing_column='trip_start_hour')
SlicingMetricsViewer(config={'weightedExamplesColumn': 'example_count'}, data=[{'slice': 'trip_start_hour:2', …

Przegląd plasterków

Wizualizacja domyślna to Przegląd plasterków, gdy liczba plasterków jest niewielka. Pokazuje wartości metryk dla każdego wycinka. Ponieważ powyżej wybraliśmy trip_start_hour , pokazuje nam dane, takie jak dokładność i AUC dla każdej godziny, co pozwala nam szukać problemów, które są specyficzne dla niektórych godzin, a nie innych.

Na powyższej wizualizacji:

  • Spróbuj posortować kolumnę funkcji, czyli naszą funkcję trip_start_hours , klikając nagłówek kolumny
  • Spróbuj posortować według precyzji i zwróć uwagę, że precyzja dla niektórych godzin z przykładami wynosi 0, co może wskazywać na problem

Wykres pozwala nam również wybierać i wyświetlać różne metryki w naszych wycinkach.

  • Spróbuj wybrać inne dane z menu „Pokaż”
  • Spróbuj wybrać przywołanie w menu „Pokaż” i zwróć uwagę, że czas przywołania dla niektórych godzin z przykładami wynosi 0, co może wskazywać na problem

Możliwe jest również ustawienie progu, aby odfiltrować wycinki z mniejszą liczbą przykładów lub „wagami”. Możesz wpisać minimalną liczbę przykładów lub użyć suwaka.

Metryki Histogram

Ten widok obsługuje również Histogram metryk jako alternatywną wizualizację, która jest również widokiem domyślnym, gdy liczba wycinków jest duża. Wyniki zostaną podzielone na segmenty i można zwizualizować liczbę wycinków / całkowitą wagę / obie. Kolumny można sortować, klikając nagłówek kolumny. Plastry o małej wadze można odfiltrować, ustawiając próg. Dalsze filtrowanie można zastosować, przeciągając szary pas. Aby zresetować zakres, kliknij dwukrotnie pasmo. Filtrowania można również użyć do usunięcia wartości odstających z wizualizacji i tabel metryk. Kliknij ikonę koła zębatego, aby przełączyć się na skalę logarytmiczną zamiast liniowej.

  • Spróbuj wybrać opcję „Metrics Histogram” w menu Wizualizacja

Więcej plasterków

Nasz początkowy tfma.EvalConfig utworzył całą listę slicing_specs , którą możemy wizualizować, aktualizując informacje o wycinku przekazywane do tfma.view.render_slicing_metrics . Tutaj wybierzemy wycinek trip_start_day (dni tygodnia). Spróbuj zmienić trip_start_day na trip_start_month i ponownie renderować, aby zbadać różne wycinki.

tfma.view.render_slicing_metrics(eval_result, slicing_column='trip_start_day')
SlicingMetricsViewer(config={'weightedExamplesColumn': 'example_count'}, data=[{'slice': 'trip_start_day:3', '…

TFMA obsługuje również tworzenie krzyżówek funkcji w celu analizy kombinacji funkcji. Nasze oryginalne ustawienia utworzyły cross trip_start_hour i trip_start_day :

tfma.view.render_slicing_metrics(
    eval_result,
    slicing_spec=tfma.SlicingSpec(
        feature_keys=['trip_start_hour', 'trip_start_day']))
SlicingMetricsViewer(config={'weightedExamplesColumn': 'example_count'}, data=[{'slice': 'trip_start_day_X_tri…

Przekraczanie dwóch kolumn tworzy wiele kombinacji! Zawęźmy nasz krzyż, aby spojrzeć tylko na wycieczki rozpoczynające się w południe . Następnie binary_accuracy z wizualizacji:

tfma.view.render_slicing_metrics(
    eval_result,
    slicing_spec=tfma.SlicingSpec(
        feature_keys=['trip_start_day'], feature_values={'trip_start_hour': '12'}))
SlicingMetricsViewer(config={'weightedExamplesColumn': 'example_count'}, data=[{'slice': 'trip_start_day_X_tri…

Renderowanie wykresów

Wszelkie wykresy, które zostały dodane do tfma.EvalConfig jako potreningowe metric_specs można wyświetlić za pomocą tfma.view.render_plot .

Podobnie jak w przypadku metryk, wykresy można przeglądać według wycinków. W przeciwieństwie do metryk, można wyświetlać tylko wykresy dla określonej wartości wycinka, więc należy użyć tfma.SlicingSpec i musi ona określać zarówno nazwę, jak i wartość funkcji wycinka. Jeśli nie ma wycinka, używane są wykresy dla wycinka Overall .

W poniższym przykładzie wyświetlamy wykresy CalibrationPlot i ConfusionMatrixPlot które zostały obliczone dla trip_start_hour:1 .

tfma.view.render_plot(
    eval_result,
    tfma.SlicingSpec(feature_values={'trip_start_hour': '1'}))
PlotViewer(config={'sliceName': 'trip_start_hour:1', 'metricKeys': {'calibrationPlot': {'metricName': 'calibra…

Śledzenie wydajności modelu w czasie

Twój zestaw danych treningowych zostanie użyty do szkolenia Twojego modelu i, miejmy nadzieję, będzie reprezentatywny dla zestawu danych testowych oraz danych, które zostaną wysłane do modelu w produkcji. Jednak chociaż dane w żądaniach wnioskowania mogą pozostać takie same jak dane uczące, w wielu przypadkach zaczną się one zmieniać na tyle, że zmieni się wydajność modelu.

Oznacza to, że musisz na bieżąco monitorować i mierzyć wydajność swojego modelu, aby być świadomym zmian i reagować na nie. Przyjrzyjmy się, jak może pomóc TFMA.

Załadujmy 3 różne przebiegi modeli i użyjmy TFMA, aby zobaczyć, jak się porównują za pomocą render_time_series .

# Note this re-uses the EvalConfig from the keras setup.

# Run eval on each saved model
output_paths = []
for i in range(3):
  # Create a tfma.EvalSharedModel that points at our saved model.
  eval_shared_model = tfma.default_eval_shared_model(
      eval_saved_model_path=os.path.join(MODELS_DIR, 'keras', str(i)),
      eval_config=keras_eval_config)

  output_path = os.path.join(OUTPUT_DIR, 'time_series', str(i))
  output_paths.append(output_path)

  # Run TFMA
  tfma.run_model_analysis(eval_shared_model=eval_shared_model,
                          eval_config=keras_eval_config,
                          data_location=tfrecord_file,
                          output_path=output_path)
WARNING:absl:Tensorflow version (2.3.1) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:absl:Tensorflow version (2.3.1) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:absl:Tensorflow version (2.3.1) found. Note that TFMA support for TF 2.0 is currently in beta

Po pierwsze, wyobrażamy sobie, że wczoraj przeszkoliliśmy i wdrożyliśmy nasz model, a teraz chcemy zobaczyć, jak sobie radzi z nowymi danymi napływającymi dzisiaj. Wizualizacja rozpocznie się wyświetleniem AUC. W interfejsie użytkownika możesz:

  • Dodaj inne dane, korzystając z menu „Dodaj serie danych”.
  • Zamknij niechciane wykresy, klikając x
  • Najedź kursorem na punkty danych (końce segmentów linii na wykresie), aby uzyskać więcej szczegółów
eval_results_from_disk = tfma.load_eval_results(output_paths[:2])

tfma.view.render_time_series(eval_results_from_disk)
TimeSeriesViewer(config={'isModelCentric': True}, data=[{'metrics': {'': {'': {'calibration': {'doubleValue': …

Teraz wyobraźmy sobie, że minął kolejny dzień i chcemy zobaczyć, jak sobie radzi z nowymi danymi napływającymi dzisiaj, w porównaniu z poprzednimi dwoma dniami:

eval_results_from_disk = tfma.load_eval_results(output_paths)

tfma.view.render_time_series(eval_results_from_disk)
TimeSeriesViewer(config={'isModelCentric': True}, data=[{'metrics': {'': {'': {'calibration': {'doubleValue': …

Walidacja modelu

TFMA można skonfigurować do oceny wielu modeli w tym samym czasie. Zwykle robi się to w celu porównania nowego modelu z poziomem bazowym (takim jak aktualnie obsługujący model) w celu ustalenia, jakie różnice w wydajności w metrykach (np. AUC, itp.) Są w stosunku do linii bazowej. Po skonfigurowaniu progów TFMA tfma.ValidationResult rekord tfma.ValidationResult wskazujący, czy wydajność jest zgodna z oczekiwaniami.

Skonfigurujmy ponownie naszą ocenę keras, aby porównać dwa modele: kandydata i linię bazową. tmfa.MetricThreshold również wydajność kandydata względem linii bazowej, ustawiając wartość tmfa.MetricThreshold na metrykę AUC.

# Setup tfma.EvalConfig setting
eval_config_with_thresholds = text_format.Parse("""
  ## Model information
  model_specs {
    name: "candidate"
    # For keras we need to add a `label_key`.
    label_key: "big_tipper"
  }
  model_specs {
    name: "baseline"
    # For keras we need to add a `label_key`.
    label_key: "big_tipper"
    is_baseline: true
  }

  ## Post training metric information
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    metrics { class_name: "BinaryAccuracy" }
    metrics { class_name: "BinaryCrossentropy" }
    metrics {
      class_name: "AUC"
      threshold {
        # Ensure that AUC is always > 0.9
        value_threshold {
          lower_bound { value: 0.9 }
        }
        # Ensure that AUC does not drop by more than a small epsilon
        # e.g. (candidate - baseline) > -1e-10 or candidate > baseline - 1e-10
        change_threshold {
          direction: HIGHER_IS_BETTER
          absolute { value: -1e-10 }
        }
      }
    }
    metrics { class_name: "AUCPrecisionRecall" }
    metrics { class_name: "Precision" }
    metrics { class_name: "Recall" }
    metrics { class_name: "MeanLabel" }
    metrics { class_name: "MeanPrediction" }
    metrics { class_name: "Calibration" }
    metrics { class_name: "CalibrationPlot" }
    metrics { class_name: "ConfusionMatrixPlot" }
    # ... add additional metrics and plots ...
  }

  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["trip_start_hour"]
  }
  slicing_specs {
    feature_keys: ["trip_start_day"]
  }
  slicing_specs {
    feature_keys: ["trip_start_month"]
  }
  slicing_specs {
    feature_keys: ["trip_start_hour", "trip_start_day"]
  }
""", tfma.EvalConfig())

# Create tfma.EvalSharedModels that point at our keras models.
candidate_model_path = os.path.join(MODELS_DIR, 'keras', '2')
baseline_model_path = os.path.join(MODELS_DIR, 'keras', '1')
eval_shared_models = [
  tfma.default_eval_shared_model(
      model_name=tfma.CANDIDATE_KEY,
      eval_saved_model_path=candidate_model_path,
      eval_config=eval_config_with_thresholds),
  tfma.default_eval_shared_model(
      model_name=tfma.BASELINE_KEY,
      eval_saved_model_path=baseline_model_path,
      eval_config=eval_config_with_thresholds),
]

validation_output_path = os.path.join(OUTPUT_DIR, 'validation')

# Run TFMA
eval_result_with_validation = tfma.run_model_analysis(
    eval_shared_models,
    eval_config=eval_config_with_thresholds,
    data_location=tfrecord_file,
    output_path=validation_output_path)
WARNING:absl:Tensorflow version (2.3.1) found. Note that TFMA support for TF 2.0 is currently in beta
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_model_analysis/evaluators/metrics_validator.py:66: RuntimeWarning: invalid value encountered in true_divide
  ratio = diff / metrics[key.make_baseline_key(baseline_model_name)]

Podczas przeprowadzania ocen z jednym lub większą liczbą modeli względem linii bazowej, TFMA automatycznie dodaje metryki różnic dla wszystkich metryk obliczonych podczas oceny. Te metryki są nazwane zgodnie z odpowiednią metryką, ale z _diff do nazwy metryki.

Rzućmy okiem na wskaźniki wygenerowane przez nasz bieg:

tfma.view.render_time_series(eval_result_with_validation)
TimeSeriesViewer(config={'isModelCentric': True}, data=[{'metrics': {'': {'': {'calibration_diff': {'doubleVal…

Przyjrzyjmy się teraz wynikom naszych sprawdzeń poprawności. Aby wyświetlić wyniki walidacji, używamy tfma.load_validator_result . W naszym przykładzie walidacja kończy się niepowodzeniem, ponieważ AUC jest poniżej progu.

validation_result = tfma.load_validation_result(validation_output_path)
print(validation_result.validation_ok)
False