Analiza modelu TensorFlow

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Przykład kluczowego komponentu TensorFlow Extended (TFX)

TensorFlow Analiza modelu (TFMA) jest biblioteką do przeprowadzania oceny modelu w różnych plasterków danych. TFMA wykonuje swoje obliczenia w równomierny sposób na duże ilości danych, z wykorzystaniem Apache belkę .

Ten przykładowy notatnik colab ilustruje, w jaki sposób TFMA może być używany do badania i wizualizacji wydajności modelu w odniesieniu do cech zestawu danych. Użyjemy modelu, który trenowaliśmy wcześniej, a teraz możesz pobawić się wynikami! Model trenowaliśmy było dla Chicago Taxi przykładu , który używa Taxi Trips zbiór danych wydany przez miasto Chicago. Poznaj pełny zestaw danych w BigQuery UI .

Jako projektant i programista zastanów się, w jaki sposób te dane są wykorzystywane i jakie potencjalne korzyści i szkody mogą spowodować prognozy modelu. Taki model mógłby wzmocnić uprzedzenia społeczne i dysproporcje. Czy funkcja jest istotna dla problemu, który chcesz rozwiązać, czy wprowadzi stronniczość? Aby uzyskać więcej informacji, przeczytaj o ML sprawiedliwości .

Kolumny w zbiorze danych to:

pickup_community_area opłata trip_start_month
trip_start_hour trip_start_day trip_start_timestamp
szerokość_odbioru długość_odbioru dropoff_latitude
dropoff_longitude podróż_mile pickup_census_tract
dropoff_census_tract typ płatności Spółka
trip_seconds dropoff_community_area porady

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 analizę modelu TensorFlow (TFMA)

To pobierze wszystkie zależności i zajmie minutę.

# Upgrade pip to the latest, and install TFMA.
pip install -U pip
pip install tensorflow-model-analysis

Teraz musisz ponownie uruchomić środowisko wykonawcze przed uruchomieniem poniższych komórek.

# This setup was tested with TF 2.5 and TFMA 0.31 (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.'

import tensorflow as tf
print('TF version: {}'.format(tf.__version__))
import apache_beam as beam
print('Beam version: {}'.format(beam.__version__))
import tensorflow_model_analysis as tfma
print('TFMA version: {}'.format(tfma.__version__))
TF version: 2.4.4
Beam version: 2.34.0
TFMA version: 0.29.0

Załaduj pliki

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

  • Zbiory danych szkoleniowych i ewaluacyjnych
  • Schemat danych
  • Uczenie i serwowanie 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  28.2M      0 --:--:-- --:--:-- --:--:-- 28.2M
Here's what we downloaded:
/tmp/tmp_at9q62d:
saved_models-2.2

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

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

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

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

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

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

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

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

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

/tmp/tmp_at9q62d/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/tmp_at9q62d/saved_models-2.2/models/estimator/serving_model_dir/eval_chicago-taxi-eval:
events.out.tfevents.1591221799.my-pipeline-b57vp-237544850

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

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

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

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

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

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

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

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

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

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

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

Przeanalizuj schemat

Wśród rzeczy, które ściągnąłem było schematu dla naszych danych, które zostały utworzone przez TensorFlow sprawdzania poprawności danych . Przeanalizujmy to teraz, abyśmy mogli używać go 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 do tworzenia 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 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/tmp_at9q62d/train_data.rio

Skonfiguruj i uruchom TFMA

TFMA obsługuje wiele różnych typów modeli, w tym modele TF Keras, modele oparte na ogólnych API sygnatur TF2, a także modele oparte na estymatorach TF. Get_started Podręcznik zawiera pełną listę obsługiwanych typów modeli i wszelkich ograniczeń. W tym przykładzie mamy zamiar pokazać, jak skonfigurować Keras modelu opartego jak również modelu opartego estymatora, który został zapisany jako EvalSavedModel . Zobacz nas na przykłady innych konfiguracjach.

TFMA zapewnia obsługę obliczania metryk, które były używane w czasie uczenia (tj. metryk wbudowanych), a także metryk zdefiniowanych po zapisaniu modelu w ramach ustawień konfiguracyjnych TFMA. Dla naszych Keras konfiguracji pokażemy dodając nasze metryki i działek ręcznie jako część naszej konfiguracji (patrz metryki przewodnik dla informacji o metryki i działek, które są obsługiwane). Do konfiguracji estymatora użyjemy wbudowanych metryk, które zostały zapisane z modelem. Nasze konfiguracje zawierają 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 użyciu tfma.run_model_analysis . Spowoduje to utworzenie tfma.EvalResult które możemy później użyć do renderowania nasze metryki i działek.

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)
2021-12-04 10:18:15.463173: W tensorflow/stream_executor/platform/default/dso_loader.cc:60] Could not load dynamic library 'libcusolver.so.10'; dlerror: libcusolver.so.10: cannot open shared object file: No such file or directory
2021-12-04 10:18:15.464249: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1757] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.
Skipping registering GPU devices...
WARNING:absl:Tensorflow version (2.4.4) 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:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.
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.7/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:113: 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.7/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:113: 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.4.4) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/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.7/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/tmp_at9q62d/saved_models-2.2/models/estimator/eval_model_dir/1591221811/variables/variables
INFO:tensorflow:Restoring parameters from /tmp/tmp_at9q62d/saved_models-2.2/models/estimator/eval_model_dir/1591221811/variables/variables
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/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.7/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 już uruchomiliśmy ocenę, przyjrzyjmy się naszym wizualizacjom przy użyciu TFMA. W poniższych przykładach zwizualizujemy wyniki z uruchomienia oceny na modelu Keras. Aby zobaczyć aktualizację modelu Estymator oparty na eval_result do punktu, w naszej estimator_eval_result zmiennej.

eval_result = keras_eval_result
# eval_result = estimator_eval_result

Wskaźniki renderowania

Aby zobaczyć metryk użyć tfma.view.render_slicing_metrics

Domyślnie widoki wyświetli Overall kawałek. Aby wyświetlić konkretny kawałek można użyć nazwy kolumny (przez ustawienie slicing_column ) lub dostarczyć 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ź na żądany punkt danych, aby zobaczyć więcej szczegółów.
  • Wybierz jeden z czterech różnych typów widoków, korzystając z opcji na dole.

Na przykład, będziemy ustawienie slicing_column spojrzeć na trip_start_hour funkcji 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

Domyślną wizualizacja jest Plastry Przegląd gdy liczba plastrów jest niewielka. Pokazuje wartości metryk dla każdego wycinka. Ponieważ wybraliśmy trip_start_hour powyżej, to pokazuje nam takie dane, jak dokładność i AUC dla każdej godziny, co pozwala nam spojrzeć na problemy, które są specyficzne dla pewnych godzinach, a nie inne.

Na powyższej wizualizacji:

  • Spróbuj sortowania kolumny funkcji, która jest naszym trip_start_hours wyposażone, klikając nagłówek kolumny
  • Spróbuj sortując precyzją, i zauważ, że precyzja dla niektórych godzin z przykładów jest 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 zauważ, że przywołanie dla niektórych godzin z przykładów jest 0, co może wskazywać na problem

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

Histogram danych

Pogląd ten obsługuje również Metrics Histogram jako alternatywny wizualizacji, która jest również domyślny widok gdy liczba plastrów jest duża. Wyniki zostaną podzielone na wiaderka i można zwizualizować liczbę kromek / wagę całkowitą / 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 pasek. Aby zresetować zakres, kliknij dwukrotnie zespół. 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 na skalę liniową.

  • Spróbuj wybrać „Histogram metryk” w menu Wizualizacja

Więcej plasterków

Nasz początkowy tfma.EvalConfig stworzył całą listę slicing_specs , które możemy wizualizować za aktualizowanie informacji slice przekazany do tfma.view.render_slicing_metrics . Tutaj będziemy wybierać trip_start_day slice (dni tygodnia). Spróbuj zmienić trip_start_day do trip_start_month i renderowania ponownie zbadać różne plastry.

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żyków cech w celu analizy kombinacji cech. Nasze oryginalne ustawienia stworzony przekrój 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…

Skrzyżowanie dwóch kolumn tworzy mnóstwo kombinacji! Załóżmy zawężenia nasz krzyż bierze pod uwagę jedynie wycieczki, które zaczynają się w południe. W takim razie wybierz binary_accuracy z wizualizacją:

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 działek

Wszelkie działek, które zostały dodane do tfma.EvalConfig jak pocztowych szkoleniowych metric_specs mogą być wyświetlane przy użyciu tfma.view.render_plot .

Podobnie jak w przypadku metryk, wykresy można przeglądać według plasterka. W przeciwieństwie do metryki, tylko działki do określonego wycinka wartości mogą być wyświetlane tak tfma.SlicingSpec musi być używany i musi określić zarówno nazwę obiektu plasterek i wartość. Jeśli nie plaster jest następnie działki o Overall wycinka służy.

W poniższym przykładzie mamy do wyświetlania CalibrationPlot i ConfusionMatrixPlot działek, które zostały obliczone dla trip_start_hour:1 plaster.

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 uczących będzie używany do uczenia modelu i, miejmy nadzieję, będzie reprezentatywny dla zestawu danych testowych oraz danych, które zostaną wysłane do modelu w środowisku produkcyjnym. Jednak chociaż dane w żądaniach wnioskowania mogą pozostać takie same jak dane treningowe, 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 na nie reagować. Przyjrzyjmy się, jak TFMA może pomóc.

Obciążenie 3 różne modele biegnie Chodźmy i stosowanie TFMA aby zobaczyć ich porównanie 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.4.4) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.
WARNING:absl:Tensorflow version (2.4.4) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.
WARNING:absl:Tensorflow version (2.4.4) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.

Najpierw wyobrazimy sobie, że wczoraj przeszkoliliśmy i wdrożyliśmy nasz model, a teraz chcemy zobaczyć, jak radzi sobie z nowymi danymi, które pojawią się dzisiaj. Wizualizacja rozpocznie się od wyświetlenia AUC. Z interfejsu użytkownika możesz:

  • Dodaj inne dane za pomocą menu „Dodaj serię 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': {'': {'': {'binary_accuracy': {'doubleValu…

Teraz wyobrazimy 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': {'': {'': {'binary_accuracy': {'doubleValu…

Walidacja modelu

TFMA można skonfigurować do jednoczesnej oceny wielu modeli. Zazwyczaj odbywa się to w celu porównania nowego modelu z punktem odniesienia (takim jak obecnie obsługujący model) w celu określenia, jakie są różnice wydajności w metrykach (np. AUC itp.) w stosunku do punktu odniesienia. Kiedy progi są skonfigurowane, TFMA będzie produkować tfma.ValidationResult zapis wskazujący, czy wydajność pasuje stanie spełnić oczekiwania.

Skonfigurujmy ponownie naszą ocenę Keras, aby porównać dwa modele: kandydat i punkt odniesienia. Będziemy również zweryfikować skuteczność kandydata przeciwko wyjściowej poprzez ustawienie tmfa.MetricThreshold na metryki 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.4.4) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.

Podczas przeprowadzania ocen z jednym lub większą liczbą modeli względem linii bazowej, TFMA automatycznie dodaje metryki diff dla wszystkich metryk obliczonych podczas oceny. Dane te są nazywane po odpowiedniej metryki ale z _diff dołączonym do nazwy metrycznym.

Przyjrzyjmy się metrykom wygenerowanym przez nasz bieg:

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

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

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