Pierwsze kroki z analizą modelu TensorFlow

Przegląd

TensorFlow Model Analysis (TFMA) to biblioteka do przeprowadzania oceny modelu.

• Dotyczy : inżynierów systemów uczących się lub naukowców zajmujących się danymi
• kto : chce przeanalizować i zrozumieć swoje modele TensorFlow
• to jest : samodzielna biblioteka lub składnik potoku TFX
• która : ocenia modele na dużych ilościach danych w sposób rozproszony na tych samych metrykach zdefiniowanych podczas uczenia. Te metryki są porównywane na wycinkach danych i wizualizowane w notatnikach Jupyter lub Colab.
• w przeciwieństwie do : niektórych narzędzi do introspekcji modeli, takich jak tensorboard, które oferują introspekcję modelu

TFMA wykonuje swoje obliczenia w sposób rozproszony na dużych ilościach danych przy użyciu Apache Beam . W poniższych sekcjach opisano, jak skonfigurować podstawowy potok oceny TFMA. Zobacz więcej szczegółów na temat architektury bazowej implementacji.

Jeśli chcesz po prostu wskoczyć i zacząć, sprawdź nasz notatnik colab .

Tę stronę można również wyświetlić na tensorflow.org .

Obsługiwane typy modeli

TFMA został zaprojektowany do obsługi modeli opartych na tensorflow, ale można go łatwo rozszerzyć, aby obsługiwał również inne struktury. Historycznie rzecz biorąc, TFMA wymagało stworzenia EvalSavedModel do używania TFMA, ale najnowsza wersja TFMA obsługuje wiele typów modeli w zależności od potrzeb użytkownika. Konfiguracja EvalSavedModel powinna być wymagana tylko wtedy, gdy używany jest model oparty na tf.estimator i wymagane są niestandardowe metryki czasu szkolenia.

Należy pamiętać, że ponieważ TFMA działa teraz w oparciu o model udostępniania, TFMA nie będzie już automatycznie oceniać metryk dodanych w czasie uczenia. Wyjątkiem od tego przypadku jest sytuacja, gdy używany jest model keras, ponieważ keras zapisuje metryki używane wraz z zapisanym modelem. Jeśli jednak jest to trudne wymaganie, najnowszy TFMA jest kompatybilny wstecz, tak że EvalSavedModel może nadal działać w potoku TFMA.

W poniższej tabeli podsumowano modele obsługiwane domyślnie:

• Metryki czasu szkolenia odnoszą się do metryk zdefiniowanych w czasie szkolenia i zapisanych z modelem (TFMA EvalSavedModel lub zapisany model keras). Metryki po treningu odnoszą się do metryk dodanych za pośrednictwem tfma.MetricConfig .
• Ogólne modele TF2 to niestandardowe modele, które eksportują sygnatury, które mogą być użyte do wnioskowania i nie są oparte ani na keras, ani na estymatorze.

Zobacz często zadawane pytania, aby uzyskać więcej informacji na temat konfigurowania i konfigurowania różnych typów modeli.

Ustawiać

Przed uruchomieniem oceny wymagana jest niewielka ilość konfiguracji. Najpierw należy zdefiniować obiekt tfma.EvalConfig który zawiera specyfikacje modelu, metryki i wycinki, które mają być ocenione. Po drugie, należy utworzyć tfma.EvalSharedModel który wskazuje na rzeczywisty model (lub modele) do wykorzystania podczas oceny. Po ich zdefiniowaniu ocena jest wykonywana przez wywołanie tfma.run_model_analysis z odpowiednim tfma.run_model_analysis danych. Więcej informacji można znaleźć w instrukcji instalacji .

Jeśli działa w potoku TFX, zobacz przewodnik TFX, aby dowiedzieć się, jak skonfigurować TFMA do działania jako składnik TFX Evaluator .

Przykłady

Ocena pojedynczego modelu

Poniższy przykład używa tfma.run_model_analysis do wykonania oceny w modelu obsługującym. Wyjaśnienie różnych potrzebnych ustawień można znaleźć w instrukcji instalacji .

# Run in a Jupyter Notebook.
from google.protobuf import text_format

eval_config = text_format.Parse("""
  ## Model information
  model_specs {
    # This assumes a serving model with a "serving_default" signature.
    label_key: "label"
    example_weight_key: "weight"
  }
  ## Post export metric information
  metrics_specs {
    # This adds AUC and as a post training metric. If the model has built in
    # training metrics which also contains AUC, this metric will replace it.
    metrics { class_name: "AUC" }
    # ... other post training metrics ...

    # Plots are also configured here...
    metrics { class_name: "ConfusionMatrixPlot" }
  }
  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["age"]
  }
""", tfma.EvalConfig())

eval_shared_model = tfma.default_eval_shared_model(
    eval_saved_model_path='/path/to/saved/model', eval_config=eval_config)

eval_result = tfma.run_model_analysis(
    eval_shared_model=eval_shared_model,
    eval_config=eval_config,
    # This assumes your data is a TFRecords file containing records in the
    # tf.train.Example format.
    data_location='/path/to/file/containing/tfrecords',
    output_path='/path/for/output')

tfma.view.render_slicing_metrics(eval_result)

W przypadku oceny rozproszonej utwórz potok Apache Beam przy użyciu rozproszonego modułu uruchamiającego. W potoku użyj tfma.ExtractEvaluateAndWriteResults do oceny i zapisania wyników. Wyniki można załadować do wizualizacji za pomocą tfma.load_eval_result .

Na przykład:

# To run the pipeline.
from google.protobuf import text_format
from tfx_bsl.tfxio import tf_example_record

eval_config = text_format.Parse("""
  ## Model information
  model_specs {
    # This assumes a serving model with a "serving_default" signature.
    label_key: "label"
    example_weight_key: "weight"
  }
  ## Post export metric information
  metrics_specs {
    # This adds AUC and as a post training metric. If the model has built in
    # training metrics which also contains AUC, this metric will replace it.
    metrics { class_name: "AUC" }
    # ... other post training metrics ...

    # Plots are also configured here...
    metrics { class_name: "ConfusionMatrixPlot" }
  }
  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["age"]
  }
""", tfma.EvalConfig())

eval_shared_model = tfma.default_eval_shared_model(
    eval_saved_model_path='/path/to/saved/model', eval_config=eval_config)

output_path = '/path/for/output'

tfx_io = tf_example_record.TFExampleRecord(
    file_pattern=data_location, raw_record_column_name=tfma.ARROW_INPUT_COLUMN)

with beam.Pipeline(runner=...) as p:
  _ = (p
       # You can change the source as appropriate, e.g. read from BigQuery.
       # This assumes your data is a TFRecords file containing records in the
       # tf.train.Example format. If using EvalSavedModel then use the following
       # instead: 'ReadData' >> beam.io.ReadFromTFRecord(file_pattern=...)
       | 'ReadData' >> tfx_io.BeamSource()
       | 'ExtractEvaluateAndWriteResults' >>
       tfma.ExtractEvaluateAndWriteResults(
            eval_shared_model=eval_shared_model,
            eval_config=eval_config,
            output_path=output_path))

# To load and visualize results.
# Note that this code should be run in a Jupyter Notebook.
result = tfma.load_eval_result(output_path)
tfma.view.render_slicing_metrics(result)

Walidacja modelu

Aby przeprowadzić walidację modelu względem kandydata i linii bazowej, zaktualizuj konfigurację, aby zawierała ustawienie progu i przekaż dwa modele do tfma.run_model_analysis .

Na przykład:

# Run in a Jupyter Notebook.
from google.protobuf import text_format

eval_config = text_format.Parse("""
  ## Model information
  model_specs {
    # This assumes a serving model with a "serving_default" signature.
    label_key: "label"
    example_weight_key: "weight"
  }
  ## Post export metric information
  metrics_specs {
    # This adds AUC and as a post training metric. If the model has built in
    # training metrics which also contains AUC, this metric will replace it.
    metrics {
      class_name: "AUC"
      threshold {
        value_threshold {
          lower_bound { value: 0.9 }
        }
        change_threshold {
          direction: HIGHER_IS_BETTER
          absolute { value: -1e-10 }
        }
      }
    }
    # ... other post training metrics ...

    # Plots are also configured here...
    metrics { class_name: "ConfusionMatrixPlot" }
  }
  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["age"]
  }
""", tfma.EvalConfig())

eval_shared_models = [
  tfma.default_eval_shared_model(
      model_name=tfma.CANDIDATE_KEY,
      eval_saved_model_path='/path/to/saved/candiate/model',
      eval_config=eval_config),
  tfma.default_eval_shared_model(
      model_name=tfma.BASELINE_KEY,
      eval_saved_model_path='/path/to/saved/baseline/model',
      eval_config=eval_config),
]

output_path = '/path/for/output'

eval_result = tfma.run_model_analysis(
    eval_shared_models,
    eval_config=eval_config,
    # This assumes your data is a TFRecords file containing records in the
    # tf.train.Example format.
    data_location='/path/to/file/containing/tfrecords',
    output_path=output_path)

tfma.view.render_slicing_metrics(eval_result)
tfma.load_validation_result(output_path)

Wyobrażanie sobie

Wyniki oceny TFMA można wizualizować w notebooku Jupyter przy użyciu komponentów frontendowych zawartych w TFMA. Na przykład:

.

Więcej informacji

• zainstalować
• Ustawiać
• Metryki i wykresy
• Walidacje modeli
• Wizualizacje
• Architektura
• FAQ
• Dokumentacja API