Przegląd
TFMA obsługuje następujące metryki i wykresy:
- Standardowe Keras metryk (
tf.keras.metrics.*
)- Należy pamiętać, że do korzystania z metryk Keras nie jest potrzebny model Keras. Metryki są obliczane poza wykresem w belce bezpośrednio przy użyciu klas metryk.
Standardowe TFMA metryki i działki (
tfma.metrics.*
)Niestandardowe Keras (metryki pochodzące z
tf.keras.metrics.Metric
)Niestandardowe TFMA (metryki pochodzące z
tfma.metrics.Metric
) za pomocą wiązki zwrotnice zwyczaj lub dane pochodzące z innych danych).
TFMA zapewnia również wbudowaną obsługę konwersji metryk klasyfikacji binarnej do wykorzystania w przypadku problemów z wieloma klasami/wieloma etykietami:
- Binaryzacja na podstawie identyfikatora klasy, top K itp.
- Zagregowane dane na podstawie uśredniania mikro, uśredniania 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.
Łącznie dostępnych jest ponad 50 standardowych wskaźników i wykresów dla różnych problemów, w tym regresji, klasyfikacji binarnej, klasyfikacji wieloklasowej/wieloetykietowej, rankingu itp.
Konfiguracja
Istnieją dwa sposoby, aby skonfigurować w TFMA danych: (1) za pomocą tfma.MetricsSpec
lub (2), poprzez utworzenie wystąpień tf.keras.metrics.*
i / lub tfma.metrics.*
Klas w pytona i za pomocą tfma.metrics.specs_from_metrics
konwertować je do listy tfma.MetricsSpec
.
W poniższych sekcjach opisano przykładowe konfiguracje dla różnych typów problemów z uczeniem maszynowym.
Metryki regresji
Poniżej znajduje się przykładowa konfiguracja konfiguracji dla problemu z regresją. Skonsultować się z tf.keras.metrics.*
I tfma.metrics.*
Moduły dla ewentualnych dodatkowych metryk obsługiwane.
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
metrics { class_name: "ExampleCount" }
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ć za pomocą następującego kodu Pythona:
metrics = [
tfma.metrics.ExampleCount(name='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ę konfiguracji dla problemu z klasyfikacją binarną. Skonsultować się z tf.keras.metrics.*
I tfma.metrics.*
Moduły dla ewentualnych dodatkowych metryk obsługiwane.
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
metrics { class_name: "ExampleCount" }
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ć za pomocą następującego kodu Pythona:
metrics = [
tfma.metrics.ExampleCount(name='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
.
Metryki klasyfikacji wieloklasowej/wieloetykietowej
Poniżej znajduje się przykładowa konfiguracja konfiguracji dla problemu klasyfikacji wieloklasowej. Skonsultować się z tf.keras.metrics.*
I tfma.metrics.*
Moduły dla ewentualnych dodatkowych metryk obsługiwane.
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
metrics { class_name: "ExampleCount" }
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 Pythona:
metrics = [
tfma.metrics.ExampleCount(name='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
.
Binarne metryki wieloklasowe/wieloetykietowe
Multi-Klasa / multi-label metryki można binaryzowany produkować metryk w klasie, za top_k itp używając 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ć za pomocą następującego kodu Pythona:
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]}))
Metryki agregatów dla wielu klas/wielu etykiet
Metryki multi-klasa / multi-label mogą być łączone w celu wytworzenia pojedynczej zagregowaną wartość dla klasyfikacji binarnej metrycznym za pomocą tfma.AggregationOptions
.
Należy pamiętać, że ustawienia są niezależne od agregacji binaryzacji ustawień, dzięki czemu można korzystać z obu tfma.AggregationOptions
i tfma.BinarizationOptions
w tym samym czasie.
Średnia mikro
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ć 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))
Micro uśredniania obsługuje również ustawienie top_k
gdzie tylko najlepszej wartości k są używane w obliczeniach. 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]}))
Makro / ważona średnia makro
Makro uśredniania można wykonać przy pomocy macro_average
lub weighted_macro_average
opcje ciągu tfma.AggregationOptions
. Chyba top_k
są używane ustawienia, makro wymaga ustawiania class_weights
aby wiedzieć, które klasy obliczyć średnią dla. Jeśli class_weight
nie jest wtedy 0,0 zakładano. 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ć 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(
macro_average=True, class_weights={i: 1.0 for i in range(10)}))
Jak uśrednianie mikro, makro uśredniania obsługuje również ustawienie top_k
gdzie tylko najlepszej wartości k są używane w obliczeniach. 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ć 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(macro_average=True,
top_k_list={'values': [1, 3]}))
Wskaźniki oparte na zapytaniach / rankingach
Query / Ranking metryki oparte są włączone, określając query_key
opcję metryk specyfikacji. 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ć za pomocą następującego kodu Pythona:
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')
Wielomodelowe metryki oceny
TFMA wspiera ewaluację wielu modeli jednocześnie. W przypadku przeprowadzania oceny wielomodelowej 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żeli dane muszą być obliczane dla podzbioru modeli ustaw model_names
w tej 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ż przechodzącej nazwy modeli:
metrics = [
...
]
metrics_specs = tfma.metrics.specs_from_metrics(
metrics, model_names=['my-model1'])
Metryki porównawcze modeli
TFMA obsługuje ocenę metryk porównawczych dla modelu kandydującego z modelem podstawowym. Prostym sposobem na skonfigurowanie pary modelu kandydującego i modelu bazowego jest przekazanie modelu 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/candidate/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ównania są obliczane automatycznie dla wszystkich metryk z możliwością różnicowania (obecnie tylko metryki wartości skalarnych, takie jak dokładność i AUC).
Metryki modelu wielowyjściowego
TFMA obsługuje ocenę metryk w modelach, które mają różne wyniki. Modele wielowyjściowe przechowują swoje prognozy wyjściowe w formie dyktatu z kluczem według nazwy wyjściowej. 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ż przechodzącej nazwy wyjściowych:
metrics = [
...
]
metrics_specs = tfma.metrics.specs_from_metrics(
metrics, output_names=['my-output'])
Dostosowywanie ustawień metryk
TFMA umożliwia dostosowanie ustawień używanych z różnymi metrykami. Na przykład może chcesz zmienić nazwę, ustalonych progów itp Odbywa się to poprzez dodanie config
sekcję do config metrycznym. Config określa się w postaci łańcucha JSON parametrów, które mają być przekazane do metryki __init__
metodą (na łatwość użycia natarcia i spływu „{” oraz „}”, wsporniki mogą być pominięte). 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
Wynikiem oceny metryki jest seria kluczy/wartości metryki i/lub kluczy/wartości wykresu na podstawie używanej konfiguracji.
Klucze metryczne
MetricKeys są definiowane za pomocą klucza typu strukturalnego. Ten klucz jednoznacznie identyfikuje każdy z następujących aspektów metryki:
- Metric nazwisko (
auc
,mean_label
, etc) - Nazwa modelu (używana tylko w przypadku oceny wielomodelowej)
- Nazwa wyjścia (używana tylko wtedy, gdy oceniane są modele z wieloma wyjściami)
- Klucz podrzędny (np. identyfikator klasy, jeśli model wieloklasowy jest zbinaryzowany)
Wartość metryki
MetricValues są zdefiniowane przy użyciu proto że encapulates różne rodzaje obsługiwanej przez różne dane (na przykład double
, ConfusionMatrixAtThresholds
itp).
Poniżej znajdują się obsługiwane typy wartości danych:
-
double_value
- owinięcie na podwójne typu. -
bytes_value
- bajty wartość. -
bounded_value
- przedstawia rzeczywistą wartość, która może być oszacowaniem punktowo, ewentualnie w przybliżonych granicach pewnego rodzaju. Posiada właściwościvalue
,lower_bound
iupper_bound
. -
value_at_cutoffs
- Value at odcięcia (np precyzja @ K @ K recall). Ma własnościvalues
, z których każdy posiada właściwościcutoff
orazvalue
. -
confusion_matrix_at_thresholds
- matryca dezorientacji progów. Ma właściwościmatrices
, z których każda posiada właściwościthreshold
,precision
,recall
i wartości macierzy błędów, takich jakfalse_negatives
. -
array_value
- dla danych powracających tablicę wartości.
Klawisze działki
PlotKeys są podobne do kluczy metrycznych chyba że ze względów historycznych wszystkie wartości działki są przechowywane w jednym proto więc kluczem działka nie ma nazwy.
Wykres wartości
Wszystkie obsługiwane Działki są przechowywane w jednym proto zwanego PlotData .
Wynik oceny
Zwrot z przebiegu ewaluacji jest tfma.EvalResult
. Ta płyta zawiera slicing_metrics
które kodują klucz metryczny jako dict wielopoziomowego, gdzie poziomy odpowiadają nazwy wyjścia, klasa ID, nazwy i wartości metrycznych, metrycznych odpowiednio. Jest to przeznaczone do wyświetlania interfejsu użytkownika w notebooku Jupiter. Jeżeli dostęp do danych źródłowych jest potrzebne metrics
wynikają plik powinien być stosowany zamiast (patrz metrics_for_slice.proto ).
Dostosowywanie
Oprócz metryk niestandardowych, które są dodawane jako część zapisanych keras (lub starszego modelu EvalSavedModel). Istnieją dwa sposoby dostosowywania metryk w zapisie TFMA: (1) przez zdefiniowanie niestandardowej klasy metryk keras oraz (2) przez zdefiniowanie niestandardowej klasy metryk TFMA wspieranej przez moduł łączenia wiązki.
W obu przypadkach metryki są konfigurowane przez określenie nazwy klasy metryki i skojarzonego 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 metryki Keras
Aby utworzyć niestandardowy Keras metryczny, użytkownicy muszą przedłużyć tf.keras.metrics.Metric
z ich wdrożenia, a następnie upewnij się, że moduł metryka jest dostępna w czasie oceny.
Należy pamiętać, że dla metryk dodanych po modelu oszczędzania, TFMA obsługuje tylko dane, które mają etykietę (tj y_true), przewidywania (y_pred), a przykładem waga (sample_weight) jako parametry do update_state
metody.
Przykład metryczny Keras
Oto 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ą TFMA metryczny, użytkownicy muszą przedłużyć tfma.metrics.Metric
z ich wdrożenia, a następnie upewnij się, że moduł metryka jest dostępna w czasie oceny.
Metryczny
tfma.metrics.Metric
realizacja składa się z zestawu kwargs określających konfigurację metryki wraz z funkcją tworzenia obliczeń (ewentualnie kilka) potrzebne do calcuate wartość metryki. Istnieją dwa główne rodzaje obliczeń, które mogą być stosowane: tfma.metrics.MetricComputation
i tfma.metrics.DerivedMetricComputation
, które są opisane w poniższych sekcjach. Funkcja, która tworzy te obliczenia, otrzyma jako dane wejściowe następujące parametry:
-
eval_config: tfam.EvalConfig
- Konfiguracja oceny przekazana do oceniającego (przydatna do wyszukiwania ustawień specyfikacji modelu, takich jak klucz przewidywania do użycia itp.).
-
model_names: List[Text]
- Lista nazw modeli do obliczania metryk (Brak w przypadku jednego modelu)
-
output_names: List[Text]
.- Lista nazw danych wyjściowych do obliczania metryk (Brak w przypadku pojedynczego modelu)
-
sub_keys: List[tfma.SubKey]
.- Lista kluczy podrzędnych (identyfikator klasy, top K itp.) do obliczania metryk (lub Brak)
-
aggregation_type: tfma.AggregationType
- Typ agregacji w przypadku obliczania metryki agregacji.
-
class_weights: Dict[int, float]
.- Wagi klas do użycia podczas 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 definicją podpisu.
Jeśli metryka jest obliczana w ten sam sposób dla każdego modelu, wyjściowego i klucz sub, następnie użytkowych tfma.metrics.merge_per_key_computations
może być używany do wykonywania tych samych obliczeń dla każdej z tych wejść osobno.
Obliczanie metryczne
MetricComputation
składa się z kombinacji preprocessor
oraz combiner
. preprocessor
jest beam.DoFn
że trwa ekstraktów jako wejścia i wyjścia stanu początkowego, który będzie używany przez sumator (patrz architekturę uzyskać więcej informacji na temat jakie są wyciągi). Jeśli preprocessor
nie jest zdefiniowana, to sumator zostanie przekazany StandardMetricInputs (Standard wejścia metrycznych zawiera etykiety, prognoz oraz example_weights). 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.
Zauważ, że krojenie dzieje między preprocessor
i combiner
.
Zauważ, że jeśli metryki obliczenie chce skorzystać zarówno standardowych wejść metrycznych, ale rozszerzyć go kilka cech z features
ekstraktów, wówczas specjalny FeaturePreprocessor można stosować które połączą żądane funkcje z wielu elementów łączących w jeden współdzieloną wartość StandardMetricsInputs, która jest przekazywana do wszystkich łączników (łączacze 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: Iterable[int]) -> int:
accumulators = iter(accumulators)
result = next(accumulator)
for accumulator in accumulators:
result += accumulator
return result
def extract_output(self,
accumulator: int) -> Dict[tfma.metrics.MetricKey, int]:
return {self._metric_key: accumulator}
Obliczenie pochodnej metryczne
DerivedMetricComputation
składa się z funkcji wynikowej, która jest używana do obliczania wartości metryki oparte na wyjściu innych obliczeń metrycznych. Funkcja wyniku pobiera dyktat obliczonych wartości jako dane wejściowe i wyprowadza dykt dodatkowych wyników metryki.
Należy zauważyć, że dopuszczalne (zalecane) jest uwzględnienie obliczeń, od których zależy obliczenie 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. Oceniający automatycznie usunie duplikaty obliczeń, które mają tę samą definicję, więc tylko jedno obliczenie zostanie uruchomione.
Przykład
Te dane TJUR stanowi dobry przykład danych pochodzących.