Komponent rurociągu TFX oceniającego

Składnik potoku Evaluator TFX wykonuje dogłębną analizę wyników uczenia modeli, aby pomóc Ci zrozumieć, jak model działa na podzbiorach danych. Ewaluator pomaga również w walidacji wyeksportowanych modeli, upewniając się, że są „wystarczająco dobre”, aby można je było wprowadzić do produkcji.

Gdy weryfikacja jest włączona, oceniający porównuje nowe modele z linią bazową (taką jak obecnie obsługujący model), aby określić, czy są „wystarczająco dobre” w stosunku do linii bazowej. Czyni to poprzez ocenę obu modeli na ewaluacyjnym zbiorze danych i obliczanie ich wydajności na podstawie metryk (np. AUC, strata). Jeśli metryki nowy model spełniają kryteria programistów określonym stosunku do modelu bazowego (np AUC nie jest niższa), model jest „błogosławiony” (oznaczone jako dobra), wskazując na Pusher , że jest OK, aby pchnąć modelu do produkcji.

  • Zużywa:
    • Eval podzielonego od ExampleGen
    • Przeszkolony modelu z trenerem
    • Model wcześniej pobłogosławiony (jeśli ma być przeprowadzona walidacja)
  • Emisje:

Ewaluator i analiza modelu TensorFlow

Oceniający wykorzystuje TensorFlow analizy modelu biblioteki do przeprowadzenia analizy, co z kolei zastosowania Apache Beam do skalowalnego przetwarzania.

Korzystanie z oceniającego komponentu

Komponent potoku Evaluator jest zazwyczaj bardzo łatwy do wdrożenia i wymaga niewielkiego dostosowania, ponieważ większość pracy jest wykonywana przez komponent Evaluator TFX.

Do konfiguracji ewaluatora potrzebne są następujące informacje:

  • Metryki do skonfigurowania (wymagane tylko wtedy, gdy dodawane są dodatkowe metryki poza tymi zapisanymi w modelu). Zobacz Tensorflow model analizy Metrics , aby uzyskać więcej informacji.
  • Plasterki do skonfigurowania (jeśli nie podano plasterków, domyślnie zostanie dodany plasterek „ogólny”). Patrz Konfiguracja Tensorflow analizy modelu , aby uzyskać więcej informacji.

Jeśli walidacja ma zostać uwzględniona, potrzebne są następujące dodatkowe informacje:

Po włączeniu weryfikacja zostanie przeprowadzona względem wszystkich zdefiniowanych metryk i wycinków.

Typowy kod wygląda tak:

import tensorflow_model_analysis as tfma
...

# For TFMA evaluation

eval_config = tfma.EvalConfig(
    model_specs=[
        # This assumes a serving model with signature 'serving_default'. If
        # using estimator based EvalSavedModel, add signature_name='eval' and
        # remove the label_key. Note, if using a TFLite model, then you must set
        # model_type='tf_lite'.
        tfma.ModelSpec(label_key='<label_key>')
    ],
    metrics_specs=[
        tfma.MetricsSpec(
            # The metrics added here are in addition to those saved with the
            # model (assuming either a keras model or EvalSavedModel is used).
            # Any metrics added into the saved model (for example using
            # model.compile(..., metrics=[...]), etc) will be computed
            # automatically.
            metrics=[
                tfma.MetricConfig(class_name='ExampleCount'),
                tfma.MetricConfig(
                    class_name='BinaryAccuracy',
                    threshold=tfma.MetricThreshold(
                        value_threshold=tfma.GenericValueThreshold(
                            lower_bound={'value': 0.5}),
                        change_threshold=tfma.GenericChangeThreshold(
                            direction=tfma.MetricDirection.HIGHER_IS_BETTER,
                            absolute={'value': -1e-10})))
            ]
        )
    ],
    slicing_specs=[
        # An empty slice spec means the overall slice, i.e. the whole dataset.
        tfma.SlicingSpec(),
        # Data can be sliced along a feature column. In this case, data is
        # sliced along feature column trip_start_hour.
        tfma.SlicingSpec(feature_keys=['trip_start_hour'])
    ])

# The following component is experimental and may change in the future. This is
# required to specify the latest blessed model will be used as the baseline.
model_resolver = Resolver(
      strategy_class=dsl.experimental.LatestBlessedModelStrategy,
      model=Channel(type=Model),
      model_blessing=Channel(type=ModelBlessing)
).with_id('latest_blessed_model_resolver')

model_analyzer = Evaluator(
      examples=examples_gen.outputs['examples'],
      model=trainer.outputs['model'],
      baseline_model=model_resolver.outputs['model'],
      # Change threshold will be ignored if there is no baseline (first run).
      eval_config=eval_config)

Oceniający wytwarza EvalResult (i ewentualnie ValidationResult Jeśli walidacja stosowano), które mogą być ładowane przy użyciu TFMA . Poniżej znajduje się przykład ładowania wyników do notatnika Jupyter:

import tensorflow_model_analysis as tfma

output_path = evaluator.outputs['evaluation'].get()[0].uri

# Load the evaluation results.
eval_result = tfma.load_eval_result(output_path)

# Visualize the metrics and plots using tfma.view.render_slicing_metrics,
# tfma.view.render_plot, etc.
tfma.view.render_slicing_metrics(tfma_result)
...

# Load the validation results
validation_result = tfma.load_validation_result(output_path)
if not validation_result.validation_ok:
  ...

Więcej szczegółów można znaleźć w dokumentacji API Evaluator .