Przegląd
TFMA obsługuje następujące metryki i wykresy:
- Standardowe metryki
tf.keras.metrics.*
(tf.keras.metrics.*
)- Pamiętaj, że nie potrzebujesz modelu keras, aby używać metryk keras. Metryki są obliczane poza wykresem w belce przy użyciu bezpośrednio klas metryk.
Standardowe metryki i wykresy
tfma.metrics.*
(tfma.metrics.*
)Niestandardowe metryki
tf.keras.metrics.Metric
(metryki pochodzące ztf.keras.metrics.Metric
)Niestandardowe metryki TFMA (metryki pochodzące z
tfma.metrics.Metric
) przy użyciu niestandardowychtfma.metrics.Metric
wiązek lub metryk pochodzących z innych metryk).
TFMA zapewnia również wbudowaną obsługę konwersji metryk klasyfikacji binarnej do użytku w przypadku problemów z wieloma klasami / wieloma etykietami:
- Binaryzacja na podstawie identyfikatora klasy, najwyższego K itp.
- Zagregowane wskaźniki oparte na uśrednianiu mikro, uśrednianiu makro itp.
TFMA zapewnia również wbudowaną obsługę metryk opartych na zapytaniach / rankingach, w których przykłady są automatycznie grupowane według klucza zapytania w potoku.
W połączeniu istnieje ponad 50+ standardowych wskaźników i wykresów dostępnych dla różnych problemów, w tym regresji, klasyfikacji binarnej, klasyfikacji wieloklasowej / wieloznakowej, rankingu itp.
Konfiguracja
Istnieją dwa sposoby konfigurowania metryk w TFMA: (1) za pomocą tfma.MetricsSpec
lub (2) poprzez utworzenie instancji tf.keras.metrics.*
I / lub tfma.metrics.*
W Pythonie i użycie tfma.metrics.specs_from_metrics
aby przekonwertować je na listę tfma.MetricsSpec
.
W poniższych sekcjach opisano przykładowe konfiguracje dla różnych typów problemów z uczeniem maszynowym.
Metryki regresji
Poniżej przedstawiono przykładową konfigurację problemu z regresją. Sprawdź tf.keras.metrics.*
I tfma.metrics.*
, Aby uzyskać informacje na temat możliwych dodatkowych obsługiwanych metryk.
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
metrics { class_name: "ExampleCount" }
metrics { class_name: "WeightedExampleCount" }
metrics { class_name: "MeanSquaredError" }
metrics { class_name: "Accuracy" }
metrics { class_name: "MeanLabel" }
metrics { class_name: "MeanPrediction" }
metrics { class_name: "Calibration" }
metrics {
class_name: "CalibrationPlot"
config: '"min_value": 0, "max_value": 10'
}
}
""", tfma.EvalConfig()).metrics_specs
Tę samą konfigurację można utworzyć przy użyciu następującego kodu w języku Python:
metrics = [
tfma.metrics.ExampleCount(name='example_count'),
tfma.metrics.WeightedExampleCount(name='weighted_example_count'),
tf.keras.metrics.MeanSquaredError(name='mse'),
tf.keras.metrics.Accuracy(name='accuracy'),
tfma.metrics.MeanLabel(name='mean_label'),
tfma.metrics.MeanPrediction(name='mean_prediction'),
tfma.metrics.Calibration(name='calibration'),
tfma.metrics.CalibrationPlot(
name='calibration', min_value=0, max_value=10)
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)
Zauważ, że ta konfiguracja jest również dostępna przez wywołanie tfma.metrics.default_regression_specs
.
Metryki klasyfikacji binarnej
Poniżej przedstawiono przykładową konfigurację dotyczącą problemu z klasyfikacją binarną. Sprawdź tf.keras.metrics.*
I tfma.metrics.*
, Aby uzyskać informacje na temat możliwych dodatkowych obsługiwanych metryk.
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
metrics { class_name: "ExampleCount" }
metrics { class_name: "WeightedExampleCount" }
metrics { class_name: "BinaryCrossentropy" }
metrics { class_name: "BinaryAccuracy" }
metrics { class_name: "AUC" }
metrics { class_name: "AUCPrecisionRecall" }
metrics { class_name: "MeanLabel" }
metrics { class_name: "MeanPrediction" }
metrics { class_name: "Calibration" }
metrics { class_name: "ConfusionMatrixPlot" }
metrics { class_name: "CalibrationPlot" }
}
""", tfma.EvalConfig()).metrics_specs
Tę samą konfigurację można utworzyć przy użyciu następującego kodu w języku Python:
metrics = [
tfma.metrics.ExampleCount(name='example_count'),
tfma.metrics.WeightedExampleCount(name='weighted_example_count'),
tf.keras.metrics.BinaryCrossentropy(name='binary_crossentropy'),
tf.keras.metrics.BinaryAccuracy(name='accuracy'),
tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
tf.keras.metrics.AUC(
name='auc_precision_recall', curve='PR', num_thresholds=10000),
tf.keras.metrics.Precision(name='precision'),
tf.keras.metrics.Recall(name='recall'),
tfma.metrics.MeanLabel(name='mean_label'),
tfma.metrics.MeanPrediction(name='mean_prediction'),
tfma.metrics.Calibration(name='calibration'),
tfma.metrics.ConfusionMatrixPlot(name='confusion_matrix_plot'),
tfma.metrics.CalibrationPlot(name='calibration_plot')
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)
Zauważ, że ta konfiguracja jest również dostępna przez wywołanie tfma.metrics.default_binary_classification_specs
.
Wieloklasowe / wieloznakowe metryki klasyfikacji
Poniżej przedstawiono przykładową konfigurację dla problemu klasyfikacji wieloklasowej. Sprawdź tf.keras.metrics.*
I tfma.metrics.*
, Aby uzyskać informacje na temat możliwych dodatkowych obsługiwanych metryk.
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
metrics { class_name: "ExampleCount" }
metrics { class_name: "WeightedExampleCount" }
metrics { class_name: "SparseCategoricalCrossentropy" }
metrics { class_name: "SparseCategoricalAccuracy" }
metrics { class_name: "Precision" config: '"top_k": 1' }
metrics { class_name: "Precision" config: '"top_k": 3' }
metrics { class_name: "Recall" config: '"top_k": 1' }
metrics { class_name: "Recall" config: '"top_k": 3' }
metrics { class_name: "MultiClassConfusionMatrixPlot" }
}
""", tfma.EvalConfig()).metrics_specs
Tę samą konfigurację można utworzyć za pomocą następującego kodu w języku Python:
metrics = [
tfma.metrics.ExampleCount(name='example_count'),
tfma.metrics.WeightedExampleCount(name='weighted_example_count'),
tf.keras.metrics.SparseCategoricalCrossentropy(
name='sparse_categorical_crossentropy'),
tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy'),
tf.keras.metrics.Precision(name='precision', top_k=1),
tf.keras.metrics.Precision(name='precision', top_k=3),
tf.keras.metrics.Recall(name='recall', top_k=1),
tf.keras.metrics.Recall(name='recall', top_k=3),
tfma.metrics.MultiClassConfusionMatrixPlot(
name='multi_class_confusion_matrix_plot'),
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)
Zauważ, że ta konfiguracja jest również dostępna przez wywołanie tfma.metrics.default_multi_class_classification_specs
.
Metryki binaryzowane dla wielu klas / wielu etykiet
Metryki wieloklasowe / wieloznakowe można binaryzować w celu uzyskania metryk według klasy, top_k itp. Przy użyciu tfma.BinarizationOptions
. Na przykład:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
binarize: { class_ids: { values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] } }
// Metrics to binarize
metrics { class_name: "AUC" }
...
}
""", tfma.EvalConfig()).metrics_specs
Tę samą konfigurację można utworzyć przy użyciu następującego kodu w języku Python:
metrics = [
// Metrics to binarize
tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
...
]
metrics_specs = tfma.metrics.specs_from_metrics(
metrics, binarize=tfma.BinarizationOptions(
class_ids={'values': [0,1,2,3,4,5,6,7,8,9]}))
Wieloklasowe / wieloznakowe wskaźniki zagregowane
Metryki wielu klas / wielu etykiet można agregować w celu uzyskania pojedynczej zagregowanej wartości dla metryki klasyfikacji binarnej przy użyciu tfma.AggregationOptions
.
Pamiętaj, że ustawienia agregacji są niezależne od ustawień binaryzacji, więc możesz używać jednocześnie tfma.AggregationOptions
i tfma.BinarizationOptions
.
Micro Average
Micro uśredniania można wykonać za pomocą micro_average
opcję w tfma.AggregationOptions
. Na przykład:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
aggregate: { micro_average: true }
// Metrics to aggregate
metrics { class_name: "AUC" }
...
}
""", tfma.EvalConfig()).metrics_specs
Tę samą konfigurację można utworzyć przy użyciu następującego kodu w języku Python:
metrics = [
// Metrics to aggregate
tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
...
]
metrics_specs = tfma.metrics.specs_from_metrics(
metrics, aggregate=tfma.AggregationOptions(micro_average=True))
Uśrednianie mikro obsługuje również ustawienie top_k
którym w obliczeniach używane są tylko najwyższe wartości k. Na przykład:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
aggregate: {
micro_average: true
top_k_list: { values: [1, 3] }
}
// Metrics to aggregate
metrics { class_name: "AUC" }
...
}
""", tfma.EvalConfig()).metrics_specs
Tę samą konfigurację można utworzyć za pomocą następującego kodu Pythona:
metrics = [
// Metrics to aggregate
tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
...
]
metrics_specs = tfma.metrics.specs_from_metrics(
metrics,
aggregate=tfma.AggregationOptions(micro_average=True,
top_k_list={'values': [1, 3]}))
Średnia makro / ważona makro
Uśrednianie makr można przeprowadzić za pomocą opcji macro_average
lub weighted_macro_average
w tfma.AggregationOptions
. O ile nie są używane ustawienia top_k
, makro wymaga ustawienia class_weights
, aby wiedzieć, dla których klas ma obliczyć średnią. Jeśli nie podano class_weight
przyjmuje się 0,0. Na przykład:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
aggregate: {
macro_average: true
class_weights: { key: 0 value: 1.0 }
class_weights: { key: 1 value: 1.0 }
class_weights: { key: 2 value: 1.0 }
class_weights: { key: 3 value: 1.0 }
class_weights: { key: 4 value: 1.0 }
class_weights: { key: 5 value: 1.0 }
class_weights: { key: 6 value: 1.0 }
class_weights: { key: 7 value: 1.0 }
class_weights: { key: 8 value: 1.0 }
class_weights: { key: 9 value: 1.0 }
}
// Metrics to aggregate
metrics { class_name: "AUC" }
...
}
""", tfma.EvalConfig()).metrics_specs
Tę samą konfigurację można utworzyć przy użyciu następującego kodu w języku Python:
metrics = [
// Metrics to aggregate
tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
...
]
metrics_specs = tfma.metrics.specs_from_metrics(
metrics,
aggregate=tfma.AggregationOptions(
macro_average=True, class_weights={i: 1.0 for i in range(10)}))
Podobnie jak mikro-uśrednianie, uśrednianie makr obsługuje również ustawienie top_k
którym w obliczeniach używane są tylko górne wartości k. Na przykład:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
aggregate: {
macro_average: true
top_k_list: { values: [1, 3] }
}
// Metrics to aggregate
metrics { class_name: "AUC" }
...
}
""", tfma.EvalConfig()).metrics_specs
Tę samą konfigurację można utworzyć przy użyciu następującego kodu w języku Python:
metrics = [
// Metrics to aggregate
tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
...
]
metrics_specs = tfma.metrics.specs_from_metrics(
metrics,
aggregate=tfma.AggregationOptions(macro_average=True,
top_k_list={'values': [1, 3]}))
Metryki oparte na zapytaniach / rankingach
Metryki oparte na zapytaniach / rankingach można włączyć, określając opcję query_key
w specyfikacjach metryk. Na przykład:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
query_key: "doc_id"
metrics {
class_name: "NDCG"
config: '"gain_key": "gain", "top_k_list": [1, 2]'
}
metrics { class_name: "MinLabelPosition" }
}
""", tfma.EvalConfig()).metrics_specs
Tę samą konfigurację można utworzyć przy użyciu następującego kodu w języku Python:
metrics = [
tfma.metrics.NDCG(name='ndcg', gain_key='gain', top_k_list=[1, 2]),
tfma.metrics.MinLabelPosition(name='min_label_position')
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics, query_key='doc_id')
Wskaźniki oceny wielu modeli
TFMA obsługuje ocenę wielu modeli w tym samym czasie. W przypadku oceny wielu modeli metryki zostaną obliczone dla każdego modelu. Na przykład:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
# no model_names means all models
...
}
""", tfma.EvalConfig()).metrics_specs
Jeśli trzeba obliczyć metryki dla podzbioru modeli, należy ustawić model_names
w parametrze metric_specs
. Na przykład:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
model_names: ["my-model1"]
...
}
""", tfma.EvalConfig()).metrics_specs
specs_from_metrics
API obsługuje również przekazywanie nazw modeli:
metrics = [
...
]
metrics_specs = tfma.metrics.specs_from_metrics(
metrics, model_names=['my-model1'])
Metryki porównania modeli
TFMA obsługuje ocenę metryk porównawczych dla modelu kandydującego względem modelu bazowego. Prostym sposobem skonfigurowania pary modeli kandydata i linii bazowej jest przekazanie eval_shared_model z odpowiednimi nazwami modeli (tfma.BASELINE_KEY i tfma.CANDIDATE_KEY):
eval_config = text_format.Parse("""
model_specs {
# ... model_spec without names ...
}
metrics_spec {
# ... metrics ...
}
""", 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),
]
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="/path/for/output")
Metryki porównawcze są obliczane automatycznie dla wszystkich możliwych do porównania metryk (obecnie tylko metryki wartości skalarnych, takie jak dokładność i AUC).
Wielowyjściowe metryki modelu
TFMA obsługuje ocenę metryk w modelach, które mają różne wyniki. Modele wielowyjściowe przechowują prognozy wyjściowe w postaci dyktowania według nazwy wyjścia. Gdy stosowane są wielo-wyjściowe modelu, nazwy wyjść związanych z zestawem wskaźników muszą być określone w output_names
części MetricsSpec. Na przykład:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
output_names: ["my-output"]
...
}
""", tfma.EvalConfig()).metrics_specs
specs_from_metrics
API obsługuje również przekazywanie nazw wyjściowych:
metrics = [
...
]
metrics_specs = tfma.metrics.specs_from_metrics(
metrics, output_names=['my-output'])
Dostosowywanie ustawień danych
TFMA umożliwia dostosowywanie ustawień używanych z różnymi metrykami. Na przykład możesz chcieć zmienić nazwę, ustawić progi itp. Odbywa się to poprzez dodanie sekcji config
do konfiguracji metryki. Konfiguracja jest określana przy użyciu ciągów JSON w wersji parametrów, które zostaną przekazane do metody __init__
metryk (dla ułatwienia użycia można pominąć początkowe i końcowe nawiasy „{” i „}”). Na przykład:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
metrics {
class_name: "ConfusionMatrixAtThresholds"
config: '"thresholds": [0.3, 0.5, 0.8]'
}
}
""", tfma.MetricsSpec()).metrics_specs
To dostosowanie jest oczywiście również obsługiwane bezpośrednio:
metrics = [
tfma.metrics.ConfusionMatrixAtThresholds(thresholds=[0.3, 0.5, 0.8]),
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)
Wyjścia
Wynik oceny metryki to seria kluczy / wartości metrycznych i / lub kluczy / wartości wykresu w oparciu o zastosowaną konfigurację.
Klucze metryczne
Klucze MetricKeys są definiowane przy użyciu typu klucza strukturalnego. Ten klucz jednoznacznie identyfikuje każdy z następujących aspektów wskaźnika:
- Metric nazwisko (
auc
,mean_label
, etc) - Nazwa modelu (używana tylko w przypadku oceny wielu modeli)
- Nazwa wyniku (używana tylko wtedy, gdy oceniane są modele wielowyjściowe)
- Podklucz (np. Identyfikator klasy, jeśli model wieloklasowy jest zbinaryzowany)
Wartość metryczna
MetricValues są definiowane przy użyciu protokołu, który zawiera różne typy wartości obsługiwane przez różne metryki (np. double
, ConfusionMatrixAtThresholds
itp.).
Poniżej znajdują się obsługiwane typy wartości danych:
-
double_value
- opakowanie dla typu double. bytes_value
- wartość w bajtach.-
bounded_value
- reprezentuje rzeczywistą wartość, która może być oszacowaniem punktowym, opcjonalnie z przybliżonymi granicami pewnego rodzaju. Ma właściwościvalue
,lower_bound
iupper_bound
. -
value_at_cutoffs
- Wartość przy odcięciach (np. precyzja @ K, przywracanie @ K). Mavalues
właściwości, z których każda mavalue
cutoff
ivalue
właściwości. -
confusion_matrix_at_thresholds
- macierz nieporozumień przy progach. Mamatrices
właściwości, z których każda ma właściwościthreshold
,precision
,recall
i wartości macierzy pomyłki, takie jakfalse_negatives
. -
array_value
- dla metryk zwracających tablicę wartości.
Klucze działki
PlotKeys są podobne do kluczy metrycznych, z wyjątkiem tego, że ze względów historycznych wszystkie wartości wykresów są przechowywane w jednym protokole, więc klucz wykresu nie ma nazwy.
Wykres wartości
Wszystkie obsługiwane wykresy są przechowywane w jednym protokole o nazwie PlotData .
EvalResult
Wynik z przebiegu oceny to tfma.EvalResult
. Ten rekord zawiera slicing_metrics
które kodują klucz metryki jako slicing_metrics
wielopoziomowe, gdzie poziomy odpowiadają odpowiednio nazwie wyjściowej, identyfikatorze klasy, nazwie metryki i wartości metryki. Jest przeznaczony do wyświetlania interfejsu użytkownika w notebooku Jupiter. Jeśli potrzebny jest dostęp do danych źródłowych, należy zamiast tego użyć pliku wyników metrics
(patrz metrics_for_slice.proto ).
Dostosowywanie
Oprócz niestandardowych metryk, które są dodawane jako część zapisanych keras (lub starszej wersji EvalSavedModel). Istnieją dwa sposoby dostosowania metryk w zapisywaniu postu TFMA: (1) przez zdefiniowanie niestandardowej klasy metryki keras i (2) przez zdefiniowanie niestandardowej klasy metryk TFMA wspartej przez łącznik wiązek.
W obu przypadkach metryki konfiguruje się, określając nazwę klasy metryki i skojarzonego z nią modułu. Na przykład:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
metrics { class_name: "MyMetric" module: "my.module"}
}
""", tfma.EvalConfig()).metrics_specs
Niestandardowe dane Keras
Aby utworzyć niestandardową metrykę keras, użytkownicy muszą rozszerzyć tf.keras.metrics.Metric
o ich implementację, a następnie upewnić się, że moduł metryki jest dostępny w czasie oceny.
Należy zauważyć, że w przypadku metryk dodanych po zapisaniu modelu TFMA obsługuje tylko metryki, które przyjmują etykietę (tj. Y_true), predykcję (y_pred) i przykładową wagę (sample_weight) jako parametry metody update_state
.
Przykład danych Keras
Poniżej znajduje się przykład niestandardowej metryki Keras:
class MyMetric(tf.keras.metrics.Mean):
def __init__(self, name='my_metric', dtype=None):
super(MyMetric, self).__init__(name=name, dtype=dtype)
def update_state(self, y_true, y_pred, sample_weight=None):
return super(MyMetric, self).update_state(
y_pred, sample_weight=sample_weight)
Niestandardowe metryki TFMA
Aby utworzyć niestandardową metrykę TFMA, użytkownicy muszą rozszerzyć tfma.metrics.Metric
o ich implementację, a następnie upewnić się, że moduł metryki jest dostępny w czasie oceny.
Metryczny
Implementacja tfma.metrics.Metric
składa się z zestawu kwargs, które definiują konfigurację metryk, wraz z funkcją do tworzenia obliczeń (prawdopodobnie wielu) potrzebnych do obliczenia wartości metryki. Istnieją dwa główne typy obliczeń, których można użyć: tfma.metrics.MetricComputation
i tfma.metrics.DerivedMetricComputation
które zostały opisane w poniższych sekcjach. Funkcja, która tworzy te obliczenia, otrzyma następujące parametry jako dane wejściowe:
-
eval_config: tfam.EvalConfig
- Konfiguracja eval przekazana do oceniającego (przydatne do wyszukiwania ustawień specyfikacji modelu, takich jak klucz prognozy do użycia itp.).
-
model_names: List[Text]
- Lista nazw modeli, dla których mają zostać obliczone metryki (brak w przypadku jednego modelu)
-
output_names: List[Text]
.- Lista nazw wyjściowych, dla których mają zostać obliczone metryki (brak w przypadku jednego modelu)
-
sub_keys: List[tfma.SubKey]
.- Lista kluczy podrzędnych (identyfikator klasy, górne K itp.) Do obliczenia metryk dla (lub Brak)
-
aggregation_type: tfma.AggregationType
- Typ agregacji w przypadku obliczania metryki agregacji.
-
class_weights: Dict[int, float]
.- Wagi klas do użycia w przypadku obliczania metryki agregacji.
-
query_key: Text
- Klucz zapytania używany podczas obliczania metryki opartej na zapytaniu / rankingu.
Jeśli metryka nie jest powiązana z co najmniej jednym z tych ustawień, może pozostawić te parametry poza swoją definicją sygnatury.
Jeśli metryka jest obliczana w ten sam sposób dla każdego modelu, wyniku i klucza podrzędnego, wówczas narzędzie tfma.metrics.merge_per_key_computations
może służyć do wykonywania tych samych obliczeń dla każdego z tych danych wejściowych oddzielnie.
MetricComputation
MetricComputation
składa się z kombinacji preprocessor
i combiner
. preprocessor
to beam.DoFn
który pobiera ekstrakty jako dane wejściowe i wyświetla stan początkowy, który będzie używany przez sumator (więcej informacji na temat tego, czym są ekstrakty, znajduje się w architekturze ). Jeśli preprocessor
nie jest zdefiniowany, to do sumatora zostanie przekazany StandardMetricInputs (standardowe dane wejściowe metryki zawierają etykiety, prognozy i przykładowe wagi). combiner
jest beam.CombineFn
że trwa krotka (klawisz plaster wyjściowy preprocesor) jako wejścia i wyjścia krotka (slice_key, wyniki metryczne dict) jako jej wynik.
Zwróć uwagę, że dzielenie odbywa się między preprocessor
a combiner
.
Zwróć uwagę, że jeśli obliczenia metryczne chcą korzystać z obu standardowych danych wejściowych metryki, ale rozszerzyć je o kilka funkcji z ekstraktów features
, można użyć specjalnego narzędzia FeaturePreprocessor, który połączy żądane funkcje z wielu kombinatorów w jeden wspólna wartość StandardMetricsInputs, która jest przekazywana do wszystkich łączników (kombinatory są odpowiedzialne za odczytywanie interesujących ich funkcji i ignorowanie pozostałych).
Przykład
Poniżej znajduje się bardzo prosty przykład definicji metryki TFMA do obliczania ExampleCount:
class ExampleCount(tfma.metrics.Metric):
def __init__(self, name: Text = 'example_count'):
super(ExampleCount, self).__init__(_example_count, name=name)
def _example_count(
name: Text = 'example_count') -> tfma.metrics.MetricComputations:
key = tfma.metrics.MetricKey(name=name)
return [
tfma.metrics.MetricComputation(
keys=[key],
preprocessor=_ExampleCountPreprocessor(),
combiner=_ExampleCountCombiner(key))
]
class _ExampleCountPreprocessor(beam.DoFn):
def process(self, extracts: tfma.Extracts) -> Iterable[int]:
yield 1
class _ExampleCountCombiner(beam.CombineFn):
def __init__(self, metric_key: tfma.metrics.MetricKey):
self._metric_key = metric_key
def create_accumulator(self) -> int:
return 0
def add_input(self, accumulator: int, state: int) -> int:
return accumulator + state
def merge_accumulators(self, accumulators: List[int]) -> int:
result = 0
for accumulator in accumulators:
result += accumulator
return result
def extract_output(self,
accumulator: int) -> Dict[tfma.metrics.MetricKey, int]:
return {self._metric_key: accumulator}
DerivedMetricComputation
DerivedMetricComputation
składa się z funkcji DerivedMetricComputation
używanej do obliczania wartości metryki na podstawie danych wyjściowych innych obliczeń metryki. Funkcja result pobiera dyktowanie obliczonych wartości jako dane wejściowe i generuje dyktowanie dodatkowych wyników metryki.
Należy zauważyć, że dopuszczalne (zalecane) jest uwzględnienie obliczeń, od których zależy wyliczenie pochodne, na liście obliczeń utworzonych przez metrykę. Pozwala to uniknąć konieczności wstępnego tworzenia i przekazywania obliczeń, które są współużytkowane przez wiele metryk. Ewaluator automatycznie usunie obliczenia, które mają taką samą definicję, więc tylko jedno obliczenie jest faktycznie wykonywane.
Przykład
Metryki TJUR stanowią dobry przykład metryk pochodnych.