Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

Metryki analizy modelu Tensorflow

Przegląd

TFMA obsługuje następujące metryki:

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 metryk 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ą protokołu MetricsSpec proto lub (2) przez utworzenie instancji tf.keras.metrics.* I / lub tfma.metrics.* W Pythonie i użycie tfma.metrics.specs_from_metrics aby przekonwertować je na MetricsSpecs.

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 regresji. 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ć 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.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 na klasę, 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 zbiorcze

Metryki wielu klas / wielu etykiet można agregować w celu uzyskania pojedynczej zagregowanej wartości dla metryki klasyfikacji binarnej.

Micro Average

Micro uśredniania można wykonać samodzielnie lub jako część binaryzacji metryk 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))

Średnia makro / ważona makro

Uśrednianie makr musi być wykonywane jako część binaryzacji metryk w połączeniu z maro_average lub weighted_macro_average w tfma.AggregationOptions . 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] } }
    aggregate: { macro_average: true }
    // Metrics to both binarize and 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 both binarize and aggregate
    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]}),
    aggregate=tfma.AggregationOptions(macro_average=True))

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"
    binarize { top_k_list: { values: [1, 2] } }
    metrics { class_name: "NDCG" config: '"gain_key": "gain"' }
  }
  metrics_specs {
    query_key: "doc_id"
    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'),
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics, query_key='doc_id', binarize=tfma.BinarizationOptions(
        top_k_list={'values': [1,2]}))

metrics = [
    tfma.metrics.MinLabelPosition(name='min_label_position')
]
metrics_specs.extend(
    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 kandydata względem modelu bazowego. Prostym sposobem skonfigurowania pary modeli kandydata i linii bazowej 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/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ą swoje prognozy wyjściowe w postaci dyktu z kluczem według nazwy wyjścia. Gdy używane są output_names , nazwy wyjść skojarzone z zestawem metryk muszą być określone w sekcji output_names w 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 łańcucha 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 podwójnego.
  • 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ści value , lower_bound i upper_bound .
  • value_at_cutoffs - Wartość przy odcięciach (np. precyzja @ K, przywracanie @ K). Ma values właściwości, z których każda ma value cutoff i value właściwości.
  • confusion_matrix_at_thresholds - macierz nieporozumień przy progach. Ma matrices właściwości, z których każda ma właściwości threshold , precision , recall i wartości macierzy pomyłki, takie jak false_negatives .
  • array_value - dla metryk zwracających tablicę wartości.

Klucze do fabuły

PlotKeys są podobne do kluczy metrycznych, z tym wyjątkiem, ż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 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 metryk niestandardowych, 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 Metric

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ń (być może wielu) potrzebnych do obliczenia wartości metryk. 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)
  • class_weights: Dict[int, float] .
    • Wagi klas do użycia przy obliczaniu 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ń oddzielnie dla każdego z tych danych wejściowych.

MetricComputation

MetricComputation składa się z kombinacji preprocessor i combiner . preprocessor to beam.DoFn który pobiera ekstrakty jako dane wejściowe i wyprowadza 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 sumator zostanie przekazany do StandardMetricInputs (standardowe dane wejściowe 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.

Zauważ, że dzielenie odbywa się między preprocessor a combiner .

Należy zauważyć, że jeśli obliczenia metryczne chcą korzystać z obu standardowych danych wejściowych metryki, ale rozszerzyć je o kilka funkcji z wyodrębnień 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 odczytanie 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 która służy do obliczania wartości metryki na podstawie wyników innych obliczeń metryki. Funkcja result pobiera dyktando obliczonych wartości jako dane wejściowe i wyświetla dodatkowe wyniki 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ń współdzielonych między wieloma metrykami. 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.