Architektura analizy modelu Tensorflow

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

Przegląd

Potok TensorFlow Model Analysis (TFMA) jest przedstawiony w następujący sposób:

Rurociąg TFMA

Rurociąg składa się z czterech głównych elementów:

  • Przeczytaj dane wejściowe
  • Ekstrakcja
  • Ocena
  • Zapisz wyniki

Te komponenty wykorzystują dwa podstawowe typy: tfma.Extracts i tfma.evaluators.Evaluation . Typ tfma.Extracts reprezentuje dane wyodrębnione podczas przetwarzania potoku i może odpowiadać co najmniej jednemu przykładowi modelu. tfma.evaluators.Evaluation reprezentuje dane wyjściowe z oceny ekstraktów w różnych punktach procesu ekstrakcji. Aby zapewnić elastyczne API, te typy są po prostu dyktami, w których klucze są zdefiniowane (zarezerwowane do użytku) przez różne implementacje. Rodzaje są zdefiniowane w następujący sposób:

# Extracts represent data extracted during pipeline processing.
# For example, the PredictExtractor stores the data for the
# features, labels, and predictions under the keys "features",
# "labels", and "predictions".
Extracts = Dict[Text, Any]

# Evaluation represents the output from evaluating extracts at
# particular point in the pipeline. The evaluation outputs are
# keyed by their associated output type. For example, the metric / plot
# dictionaries from evaluating metrics and plots will be stored under
# "metrics" and "plots" respectively.
Evaluation = Dict[Text, beam.pvalue.PCollection]

Zwróć uwagę, że tfma.Extracts nigdy nie są zapisywane bezpośrednio, zawsze muszą przejść przez ewaluatora, aby utworzyć tfma.evaluators.Evaluation , który jest następnie wypisywany. Należy również zauważyć, że tfma.Extracts to komunikaty przechowywane w beam.pvalue.PCollection (tzn beam.PTransform przyjmuje jako dane wejściowe beam.pvalue.PCollection[tfma.Extracts] ), podczas gdy tfma.evaluators.Evaluation to komunikat, którego wartości są beam.pvalue.PCollection s (tzn beam.PTransform s przyjmują sam dict jako argument dla danych wejściowych beam.value.PCollection ). Innymi słowy, tfma.evaluators.Evaluation jest używany podczas budowy potoku, ale tfma.Extracts są używane w czasie wykonywania potoku.

Przeczytaj dane wejściowe

Etap ReadInputs składa się z transformacji, która pobiera surowe dane wejściowe (tf.train.Example, CSV, ...) i konwertuje je na fragmenty. Obecnie ekstrakty są reprezentowane jako surowe bajty wejściowe przechowywane w tfma.INPUT_KEY , jednak ekstrakty mogą mieć dowolną formę, która jest zgodna z potokiem ekstrakcji – co oznacza, że ​​tworzy tfma.Extracts jako dane wyjściowe i że te ekstrakty są kompatybilne z dalszymi ekstraktory. Od różnych ekstraktorów zależy, czy jasno udokumentowają to, czego potrzebują.

Ekstrakcja

Proces ekstrakcji to lista beam.PTransform , które są uruchamiane szeregowo. Ekstraktory pobierają tfma.Extracts jako dane wejściowe i zwracają tfma.Extracts jako dane wyjściowe. Prototypowym ekstraktorem jest tfma.extractors.PredictExtractor , który wykorzystuje ekstrakt wejściowy wytworzony przez transformację odczytanych danych wejściowych i przepuszcza go przez model w celu wygenerowania ekstraktów prognoz. Niestandardowe ekstraktory można wstawiać w dowolnym momencie, pod warunkiem, że ich przekształcenia są zgodne z interfejsami API tfma.Extracts in i tfma.Extracts out. Ekstraktor definiuje się w następujący sposób:

# An Extractor is a PTransform that takes Extracts as input and returns
# Extracts as output. A typical example is a PredictExtractor that receives
# an 'input' placeholder for input and adds additional 'predictions' extracts.
Extractor = NamedTuple('Extractor', [
    ('stage_name', Text),
    ('ptransform', beam.PTransform)])  # Extracts -> Extracts

InputExtractor

tfma.extractors.InputExtractor służy do wyodrębniania nieprzetworzonych funkcji, nieprzetworzonych etykiet i nieprzetworzonych wag przykładowych z rekordów tf.train.Example do wykorzystania w wycinaniu metryk i obliczeniach. Domyślnie wartości są przechowywane odpowiednio w kluczach wyodrębniania features , labels i example_weights . Etykiety modeli z jednym wyjściem i przykładowe wagi są przechowywane bezpośrednio jako wartości np.ndarray . Etykiety modeli z wieloma wyjściami i przykładowe wagi są przechowywane jako wpisy wartości np.ndarray (kluczowane według nazwy wyjścia). Jeśli wykonywana jest ocena wielu modeli, etykiety i przykładowe wagi zostaną dalej osadzone w innym dykcie (kluczem według nazwy modelu).

PredictExtractor

tfma.extractors.PredictExtractor uruchamia prognozy modelu i przechowuje je pod kluczowymi predictions w tfma.Extracts . Prognozy modelu z jednym wyjściem są przechowywane bezpośrednio jako przewidywane wartości wyjściowe. Prognozy modelu wielowyjściowego są przechowywane jako dykta wartości wyjściowych (kluczowych według nazwy danych wyjściowych). Jeśli przeprowadzana jest ocena wielomodelowa, predykcja zostanie dalej osadzona w innym dykcie (oznaczonym nazwą modelu). Rzeczywista używana wartość wyjściowa zależy od modelu (np. zwracane przez TF estymatora dane wyjściowe w postaci dyktatu, podczas gdy keras zwraca wartości np.ndarray ).

SliceKeyExtractor

tfma.extractors.SliceKeyExtractor używa specyfikacji wycinania, aby określić, które wycinki mają zastosowanie do każdego przykładowego wejścia na podstawie wyodrębnionych funkcji, i dodaje odpowiadające im wartości wycinania do wyciągów do późniejszego wykorzystania przez oceniających.

Ocena

Ocena to proces pobierania wyciągu i oceny go. Chociaż często przeprowadza się ocenę na końcu potoku ekstrakcji, istnieją przypadki użycia, które wymagają oceny na wcześniejszym etapie procesu ekstrakcji. W związku z tym ewaluatorzy są powiązani z ekstraktorami, których wyniki powinny być oceniane. Ewaluatora definiuje się w następujący sposób:

# An evaluator is a PTransform that takes Extracts as input and
# produces an Evaluation as output. A typical example of an evaluator
# is the MetricsAndPlotsEvaluator that takes the 'features', 'labels',
# and 'predictions' extracts from the PredictExtractor and evaluates
# them using post export metrics to produce metrics and plots dictionaries.
Evaluator = NamedTuple('Evaluator', [
  ('stage_name', Text),
  ('run_after', Text),              # Extractor.stage_name
  ('ptransform', beam.PTransform)]) # Extracts -> Evaluation

Zauważ, że ewaluatorem jest beam.PTransform , który przyjmuje tfma.Extracts jako dane wejściowe. Nic nie powstrzymuje implementacji przed wykonaniem dodatkowych przekształceń na ekstraktach w ramach procesu oceny. W przeciwieństwie do ekstraktorów, które muszą zwracać dyktat tfma.Extracts , nie ma ograniczeń co do typów danych wyjściowych, które ewaluator może wygenerować, chociaż większość ewaluatorów również zwraca dyktat (np. nazwy i wartości metryk).

Ewaluator metryk i wykresów

tfma.evaluators.MetricsAndPlotsEvaluator pobiera features , labels i predictions jako dane wejściowe, przetwarza je za pomocą tfma.slicer.FanoutSlices w celu pogrupowania ich według wycinków, a następnie wykonuje metryki i obliczenia wykresów. Daje dane wyjściowe w postaci słowników metryk oraz wykresów kluczy i wartości (są one później konwertowane na zserializowane protosy do wyjścia przez tfma.writers.MetricsAndPlotsWriter ).

Zapisz wyniki

Etap WriteResults to miejsce, w którym dane wyjściowe oceny są zapisywane na dysku. WriteResults używa pisarzy do zapisywania danych na podstawie kluczy wyjściowych. Na przykład tfma.evaluators.Evaluation może zawierać klucze do metrics i plots . Zostaną one następnie powiązane ze słownikami metryk i wykresów, zwanymi „metrykami” i „wykresami”. Autorzy określają, jak zapisać każdy plik:

# A writer is a PTransform that takes evaluation output as input and
# serializes the associated PCollections of data to a sink.
Writer = NamedTuple('Writer', [
  ('stage_name', Text),
  ('ptransform', beam.PTransform)])    # Evaluation -> PDone

Pisarz metryk i wykresów

tfma.writers.MetricsAndPlotsWriter , który konwertuje metryki i słowniki wykresów na serializowane protos i zapisuje je na dysku.

Jeśli chcesz użyć innego formatu serializacji, możesz utworzyć niestandardowy program do zapisywania i użyć go zamiast tego. Ponieważ tfma.evaluators.Evaluation przekazywana do autorów zawiera dane wyjściowe dla wszystkich ewaluatorów łącznie, zapewniona jest transformacja pomocnicza tfma.writers.Write , której autorzy mogą używać w swoich implementacjach ptransform , aby wybrać odpowiednią beam.PCollection s w oparciu o klawisz wyjścia (patrz przykład poniżej).

Dostosowywanie

Metoda tfma.run_model_analysis pobiera argumenty extractors , evaluators i writers w celu dostosowania ekstraktorów, oceniających i zapisujących używanych przez potok. Jeśli nie podano żadnych argumentów, domyślnie używane są tfma.default_extractors , tfma.default_evaluators i tfma.default_writers .

Ekstraktory niestandardowe

Aby utworzyć niestandardowy ekstraktor, utwórz typ tfma.extractors.Extractor , który otacza beam.PTransform , przyjmując tfma.Extracts jako dane wejściowe i zwracając tfma.Extracts jako dane wyjściowe. Przykłady ekstraktorów są dostępne w tfma.extractors .

Niestandardowi oceniający

Aby utworzyć niestandardowy ewaluator, utwórz typ tfma.evaluators.Evaluator , który otacza beam.PTransform , przyjmując tfma.Extracts jako dane wejściowe i zwracając tfma.evaluators.Evaluation jako dane wyjściowe. Bardzo prosty ewaluator może po prostu wziąć przychodzące tfma.Extracts i wyprowadzić je do przechowywania w tabeli. To jest dokładnie to, co robi tfma.evaluators.AnalysisTableEvaluator . Bardziej skomplikowany ewaluator może wykonać dodatkowe przetwarzanie i agregację danych. Zobacz tfma.evaluators.MetricsAndPlotsEvaluator jako przykład.

Należy zauważyć, że sam tfma.evaluators.MetricsAndPlotsEvaluator można dostosować do obsługi metryk niestandardowych (więcej szczegółów można znaleźć w metrykach ).

Niestandardowi pisarze

Aby utworzyć niestandardowy program zapisujący, utwórz typ tfma.writers.Writer , który zawija beam.PTransform , przyjmując tfma.evaluators.Evaluation jako dane wejściowe i zwracając beam.pvalue.PDone jako dane wyjściowe. Poniżej znajduje się podstawowy przykład pisarza do zapisywania TFRecords zawierających metryki:

tfma.writers.Writer(
  stage_name='WriteTFRecord(%s)' % tfma.METRICS_KEY,
  ptransform=tfma.writers.Write(
    key=tfma.METRICS_KEY,
    ptransform=beam.io.WriteToTFRecord(file_path_prefix=output_file))

Dane wejściowe pisarza zależą od danych wyjściowych skojarzonego oceniającego. W powyższym przykładzie dane wyjściowe to serializowany proto tworzony przez tfma.evaluators.MetricsAndPlotsEvaluator . Autor tfma.evaluators.AnalysisTableEvaluator byłby odpowiedzialny za napisanie beam.pvalue.PCollection tfma.Extracts .

Zauważ, że zapisujący jest powiązany z danymi wyjściowymi oceniającego za pomocą użytego klucza wyjściowego (np. tfma.METRICS_KEY , tfma.ANALYSIS_KEY , itp.).

Przykład krok po kroku

Poniżej przedstawiono przykład kroków związanych z potokiem ekstrakcji i oceny, gdy używane są zarówno tfma.evaluators.MetricsAndPlotsEvaluator , jak i tfma.evaluators.AnalysisTableEvaluator :

run_model_analysis(
    ...
    extractors=[
        tfma.extractors.InputExtractor(...),
        tfma.extractors.PredictExtractor(...),
        tfma.extractors.SliceKeyExtrator(...)
    ],
    evaluators=[
        tfma.evaluators.MetricsAndPlotsEvaluator(...),
        tfma.evaluators.AnalysisTableEvaluator(...)
    ])

ReadInputs

# Out
Extracts {
  'input': bytes                 # CSV, Proto, ...
}

ExtractAndEvaluate

# In:  ReadInputs Extracts
# Out:
Extracts {
  'input': bytes                    # CSV, Proto, ...
  'features': tensor_like           # Raw features
  'labels': tensor_like             # Labels
  'example_weights': tensor_like    # Example weights
}

# In:  InputExtractor Extracts
# Out:
Extracts {
  'input': bytes                    # CSV, Proto, ...
  'features': tensor_like           # Raw features
  'labels': tensor_like             # Labels
  'example_weights': tensor_like    # Example weights
  'predictions': tensor_like        # Predictions
}

# In: PredictExtractor Extracts
# Out:
Extracts {
  'features': tensor_like           # Raw features
  'labels': tensor_like             # Labels
  'example_weights': tensor_like    # Example weights
  'predictions': tensor_like        # Predictions
  'slice_key': Tuple[bytes...]      # Slice
}

# In: SliceKeyExtractor Extracts
# Out:
Evaluation {
  'metrics': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from metric key to metric values)
  'plots': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from plot key to plot values)
}

# In: SliceKeyExtractor Extracts
# Out:
Evaluation {
  'analysis': PCollection[Extracts] # Final Extracts
}

WriteResults

# In:
Evaluation {
  'metrics': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from metric key to metric values)
  'plots': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from plot key to plot values)
  'analysis': PCollection[Extracts] # Final Extracts
}
# Out: metrics, plots, and analysis files