Treten Sie der SIG TFX-Addons-Community bei und helfen Sie mit, TFX noch besser zu machen! SIG TFX-Addons beitreten

Referenz zu TensorFlow-Datenvalidierungsanomalien

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

TFDV prüft auf Anomalien, indem es ein Schema und Statistikprotokolle vergleicht. In der folgenden Tabelle sind die Anomalietypen aufgeführt, die TFDV erkennen kann, die Schema- und Statistikfelder, mit denen jeder Anomalietyp erkannt wird, sowie die Bedingungen, unter denen jeder Anomalietyp erkannt wird.

  • BOOL_TYPE_BIG_INT

    • Schemafelder:
      • feature.bool_domain
      • feature.type
    • Statistikfelder:
      • feature.num_stats.max
    • Erkennungsbedingung:
      • feature.type == INT und
      • feature.bool_domain ist angegeben und
      • feature.num_stats.max > 1
  • BOOL_TYPE_BYTES_NOT_INT

    • Anomalietyp in TFDV nicht erkannt
  • BOOL_TYPE_BYTES_NOT_STRING

    • Anomalietyp in TFDV nicht erkannt
  • BOOL_TYPE_FLOAT_NOT_INT

    • Anomalietyp in TFDV nicht erkannt
  • BOOL_TYPE_FLOAT_NOT_STRING

    • Anomalietyp in TFDV nicht erkannt
  • BOOL_TYPE_INT_NOT_STRING

    • Anomalietyp in TFDV nicht erkannt
  • BOOL_TYPE_SMALL_INT

    • Schemafelder:
      • feature.bool_domain
      • feature.type
    • Statistikfelder:
      • feature.num_stats.min
    • Erkennungsbedingung:
      • feature.type == INT und
      • feature.bool_domain ist angegeben und
      • feature.num_stats.min <0
  • BOOL_TYPE_STRING_NOT_INT

    • Anomalietyp in TFDV nicht erkannt
  • BOOL_TYPE_UNEXPECTED_STRING

    • Schemafelder:
      • feature.bool_domain
      • feature.type
    • Statistikfelder:
      • feature.string_stats.rank_histogram *
    • Erkennungsbedingung:
      • Mindestens ein Wert in rank_histogram ist nicht feature.bool_domain.true_value oder feature.bool_domain.false_value
  • BOOL_TYPE_UNEXPECTED_FLOAT

    • Schemafelder:
      • feature.bool_domain
      • feature.type
    • Statistikfelder:
      • feature.num_stats.min
      • feature.num_stats.max
      • feature.num_stats.histograms.num_nan
      • feature.num_stats.histograms.buckets.low_value
      • feature.num_stats.histograms.buckets.high_value
    • Erkennungsbedingung:
      • feature.type == FLOAT und
      • feature.bool_domain ist angegeben und
      • feature.num_stats.min ! = 0 und feature.num_stats.min ! = 1 oder
        feature.num_stats.max ! = 0 und feature.num_stats.max ! = 1 oder
        feature.num_stats.histograms.num_nan > 0 oder
        feature.num_stats.histograms.buckets.low_value <0 oder
        feature.num_stats.histograms.buckets.high_value > 1 oder
        feature.num_stats.histograms.buckets.low_value > 0 und high_value <1
  • ENUM_TYPE_BYTES_NOT_STRING

    • Anomalietyp in TFDV nicht erkannt
  • ENUM_TYPE_FLOAT_NOT_STRING

    • Anomalietyp in TFDV nicht erkannt
  • ENUM_TYPE_INT_NOT_STRING

    • Anomalietyp in TFDV nicht erkannt
  • ENUM_TYPE_INVALID_UTF8

    • Statistikfelder:
      • feature.string_stats.rank_histogram *
    • Erkennungsbedingung:
      • Mindestens ein Wert in rank_histogram kann nicht als utf-8 dekodiert werden
  • ENUM_TYPE_UNEXPECTED_STRING_VALUES

    • Schemafelder:
      • string_domain und feature.domain ; oder feature.string_domain
      • feature.distribution_constraints.min_domain_mass
    • Statistikfelder:
      • feature.string_stats.rank_histogram *
    • Erkennungsbedingung:

      • (Anzahl der Werte in rank_histogram , die sich nicht in der Domäne befinden / Gesamtzahl der Werte)> (1 - feature.distribution_constraints.min_domain_mass ); oder

      • feature.distribution_constraints.min_domain_mass == 1.0 und es gibt Werte im Histogramm, die sich nicht in der Domäne befinden

  • FEATURE_TYPE_HIGH_NUMBER_VALUES

    • Schemafelder:
      • feature.value_count.max
      • feature.value_counts.value_count.max
    • Statistikfelder:
      • feature.common_stats.max_num_values
      • feature.common_stats.presence_and_valency_stats.max_num_values
    • Erkennungsbedingung:
      • feature.value_count.max ist angegeben und
      • feature.common_stats.max_num_values > feature.value_count.max ; oder
      • feature.value_counts ist angegeben und
      • feature.common_stats.presence_and_valency_stats.max_num_values > feature.value_counts.value_count.max bei einer bestimmten Verschachtelungsstufe
  • FEATURE_TYPE_LOW_FRACTION_PRESENT

    • Schemafelder:
      • feature.presence.min_fraction
    • Statistikfelder:
      • feature.common_stats.num_non_missing *
      • num_examples *
    • Erkennungsbedingung:
      • feature.presence.min_fraction ist angegeben und ( feature.common_stats.num_non_missing / num_examples ) < feature.presence.min_fraction ; oder
      • feature.presence.min_fraction == 1.0 und common_stats.num_missing ! = 0
  • FEATURE_TYPE_LOW_NUMBER_PRESENT

    • Schemafelder:
      • feature.presence.min_count
    • Statistikfelder:
      • feature.common_stats.num_non_missing *
    • Erkennungsbedingung:
      • feature.presence.min_count ist angegeben und
      • feature.common_stats.num_non_missing == 0 oder feature.common_stats.num_non_missing < feature.presence.min_count
  • FEATURE_TYPE_LOW_NUMBER_VALUES

    • Schemafelder:
      • feature.value_count.min
      • feature.value_counts.value_count.min
    • Statistikfelder:
      • feature.common_stats.min_num_values
      • feature.common_stats.presence_and_valency_stats.min_num_values
    • Erkennungsbedingung:
      • feature.value_count.min ist angegeben und
      • feature.common_stats.min_num_values < feature.value_count.min ; oder
      • feature.value_counts ist angegeben und
      • feature.common_stats.presence_and_valency_stats.min_num_values < feature.value_counts.value_count.min bei einer bestimmten Verschachtelungsstufe
  • FEATURE_TYPE_NOT_PRESENT

    • Schemafelder:
      • feature.in_environment oder feature.not_in_environment oder schema.default_environment
      • feature.lifecycle_stage
      • feature.presence.min_count oder feature.presence.min_fraction
    • Statistikfelder:
      • feature.common_stats.num_non_missing *
    • Erkennungsbedingung:
      • feature.lifecycle_stage ! = PLANNED , ALPHA , DEBUG oder DEPRECATED und
      • feature.presence.min_count > 0 oder feature.presence.min_fraction > 0 und
      • feature.in_environment == aktuelle Umgebung oder feature.not_in_environment ! = aktuelle Umgebung oder schema.default_environment ! = aktuelle Umgebung und
      • common_stats.num_non_missing * == 0
  • FEATURE_TYPE_NO_VALUES

    • Anomalietyp in TFDV nicht erkannt
  • FEATURE_TYPE_UNEXPECTED_REPEATED

    • Anomalietyp in TFDV nicht erkannt
  • FEATURE_TYPE_HIGH_UNIQUE

    • Schemafelder:
      • feature.unique_constraints.max
    • Statistikfelder:
      • feature.string_stats.unique
    • Erkennungsbedingung:
      • feature.string_stats.unique > feature.unique_constraints.max
  • FEATURE_TYPE_LOW_UNIQUE

    • Schemafelder:
      • feature.unique_constraints.min
    • Statistikfelder:
      • feature.string_stats.unique
    • Erkennungsbedingung:
      • feature.string_stats.unique < feature.unique_constraints.min
  • FEATURE_TYPE_NO_UNIQUE

    • Schemafelder:
      • feature.unique_constraints
    • Statistikfelder:
      • feature.string_stats.unique
    • Erkennungsbedingung:
      • feature.unique_constraints angegeben, aber keine feature.string_stats.unique vorhanden (wie es der Fall ist, wenn das Feature keine Zeichenfolge oder Kategorie ist)
  • FLOAT_TYPE_BIG_FLOAT

    • Schemafelder:
      • feature.float_domain.max
    • Statistikfelder:
      • feature.type
      • feature.num_stats.max oder feature.string_stats.rank_histogram
    • Erkennungsbedingung:
      • feature.type == FLOAT , BYTES oder STRING und
      • wenn feature.type ist FLOAT : feature.num_stats.max > feature.float_domain.max
      • Wenn feature.type BYTES oder STRING : Maximalwert in feature.string_stats.rank_histogram (bei Konvertierung in float)> feature.float_domain.max
  • FLOAT_TYPE_NOT_FLOAT

    • Anomalietyp in TFDV nicht erkannt
  • FLOAT_TYPE_SMALL_FLOAT

    • Schemafelder:
      • feature.float_domain.min
    • Statistikfelder:
      • feature.type
      • feature.num_stats.min oder feature.string_stats.rank_histogram
    • Erkennungsbedingung:
      • feature.type == FLOAT , BYTES oder STRING und
      • wenn feature.type ist FLOAT : feature.num_stats.min <feature.float_domain.min
      • Wenn feature.type BYTES oder STRING : Mindestwert in feature.string_stats.rank_histogram (bei Konvertierung in float) <feature.float_domain.min
  • FLOAT_TYPE_STRING_NOT_FLOAT

    • Schemafelder:
      • feature.float_domain
    • Statistikfelder:
      • feature.type
      • feature.string_stats.rank_histogram
    • Erkennungsbedingung:
      • feature.type == BYTES oder STRING und
      • feature.string_stats.rank_histogram hat mindestens einen Wert, der nicht in einen Float konvertiert werden kann
  • FLOAT_TYPE_NON_STRING

    • Anomalietyp in TFDV nicht erkannt
  • FLOAT_TYPE_UNKNOWN_TYPE_NUMBER

    • Anomalietyp in TFDV nicht erkannt
  • FLOAT_TYPE_HAS_NAN

    • Schemafelder:
      • feature.float_domain.disallow_nan
    • Statistikfelder:
      • feature.type
      • feature.num_stats.histograms.num_nan
    • Erkennungsbedingung:
      • float_domain.disallow_nan is true und
      • feature.num_stats.histograms.num_nan > 0
  • FLOAT_TYPE_HAS_INF

    • Schemafelder:
      • feature.float_domain.disallow_inf
    • Statistikfelder:
      • feature.type
      • feature.num_stats.min
      • feature.num_stats.max
    • Erkennungsbedingung:
      • float_domain.disallow_inf is true und
      • feature.num_stats.min == inf/-inf oder
      • feature.num_stats.max == inf/-inf
  • INT_TYPE_BIG_INT

    • Schemafelder:
      • feature.int_domain.max
    • Statistikfelder:
      • feature.type
      • feature.num_stats.max oder feature.string_stats.rank_histogram
    • Erkennungsbedingung:
      • feature.type == INT , BYTES oder STRING und
      • Wenn feature.type INT : feature.num_stats.max > feature.int_domain.max
      • Wenn feature.type BYTES oder STRING : Maximalwert in feature.string_stats.rank_histogram (bei Konvertierung in int)> feature.int_domain.max
  • INT_TYPE_INT_EXPECTED

    • Anomalietyp in TFDV nicht erkannt
  • INT_TYPE_NOT_INT_STRING

    • Schemafelder:
      • feature.int_domain
    • Statistikfelder:
      • feature.type
      • feature.string_stats.rank_histogram
    • Erkennungsbedingung:
      • feature.type == BYTES oder STRING und
      • feature.string_stats.rank_histogram hat mindestens einen Wert, der nicht in einen int konvertiert werden kann
  • INT_TYPE_NOT_STRING

    • Anomalietyp in TFDV nicht erkannt
  • INT_TYPE_SMALL_INT

    • Schemafelder:
      • feature.int_domain.min
    • Statistikfelder:
      • feature.type
      • feature.num_stats.min oder feature.string_stats.rank_histogram
    • Erkennungsbedingung:
      • feature.type == INT , BYTES oder STRING und
      • Wenn feature.type INT : feature.num_stats.min < feature.int_domain.min
      • Wenn feature.type BYTES oder STRING : Mindestwert in feature.string_stats.rank_histogram (bei Konvertierung in int) < feature.int_domain.min
  • INT_TYPE_STRING_EXPECTED

    • Anomalietyp in TFDV nicht erkannt
  • INT_TYPE_UNKNOWN_TYPE_NUMBER

    • Anomalietyp in TFDV nicht erkannt
  • LOW_SUPPORTED_IMAGE_FRACTION

    • Schemafelder:
      • feature.image_domain.minimum_supported_image_fraction
    • Statistikfelder:
      • feature.custom_stats.rank_histogram für die custom_stats mit dem Namen image_format_histogram . Beachten Sie, dass semantische Domänenstatistiken aktiviert sein müssen, damit das image_format_histogram generiert und diese Validierung durchgeführt werden kann. Semantische Domänenstatistiken werden standardmäßig nicht generiert.
    • Erkennungsbedingung:
      • Der Anteil der Werte, die Tensorflow-Bildtypen für alle Bildtypen unterstützen, ist geringer als feature.image_domain.minimum_supported_image_fraction .
  • MAX_IMAGE_BYTE_SIZE_EXCEEDED

    • Schemafelder:
      • feature.image_domain.max_image_byte_size
    • Statistikfelder:
      • feature.bytes_stats.max_num_bytes_int
    • Erkennungsbedingung:
      • max_num_bytes_int > max_image_byte_size
  • SCHEMA_MISSING_COLUMN

    • Schemafelder:
      • feature.in_environment oder feature.not_in_environment oder schema.default_environment
      • feature.lifecycle_stage
      • feature.presence.min_count oder feature.presence.min_fraction
    • Erkennungsbedingung:
      • feature.lifecycle_stage ! = PLANNED , ALPHA , DEBUG oder DEPRECATED und
      • feature.presence.min_count > 0 oder feature.presence.min_fraction > 0 und
      • feature.in_environment == aktuelle Umgebung oder feature.not_in_environment ! = aktuelle Umgebung oder schema.default_environment ! = aktuelle Umgebung und
      • Im Statistikprotokoll wurde keine Funktion mit dem angegebenen Namen / Pfad gefunden
  • SCHEMA_NEW_COLUMN

    • Erkennungsbedingung:
      • Es gibt eine Funktion im Statistik-Proto, aber keine Funktion mit ihrem Namen / Pfad im Schema-Proto
  • SCHEMA_TRAINING_SERVING_SKEW

    • Anomalietyp in TFDV nicht erkannt
  • STRING_TYPE_NOW_FLOAT

    • Anomalietyp in TFDV nicht erkannt
  • STRING_TYPE_NOW_INT

    • Anomalietyp in TFDV nicht erkannt
  • COMPARATOR_CONTROL_DATA_MISSING

    • Schemafelder:
      • feature.skew_comparator.infinity_norm.threshold
      • feature.drift_comparator.infinity_norm.threshold
    • Erkennungsbedingung:
      • Das Kontrollstatistik-Proto (dh das Bereitstellen von Statistiken für den Versatz oder frühere Statistiken für die Drift) ist verfügbar, enthält jedoch nicht die angegebene Funktion
  • COMPARATOR_TREATMENT_DATA_MISSING

    • Anomalietyp in TFDV nicht erkannt
  • COMPARATOR_L_INFTY_HIGH

    • Schemafelder:
      • feature.skew_comparator.infinity_norm.threshold
      • feature.drift_comparator.infinity_norm.threshold
    • Statistikfelder:
      • feature.string_stats.rank_histogram *
    • Erkennungsbedingung:
      • L-Unendlichkeitsnorm des Vektors, der die Differenz zwischen den normalisierten Zählungen aus dem feature.string_stats.rank_histogram in der Kontrollstatistik (dh Serving-Statistik für Versatz oder vorherige Statistik für Drift) und der Behandlungsstatistik (dh Trainingsstatistik für Versatz) darstellt oder aktuelle Statistiken für Drift)> feature.skew_comparator.infinity_norm.threshold oder feature.drift_comparator.infinity_norm.threshold
  • COMPARATOR_JENSEN_SHANNON_DIVERGENCE_HIGH

    • Schemafelder:
      • feature.skew_comparator.jensen_shannon_divergence.threshold
      • feature.drift_comparator.jensen_shannon_divergence.threshold
    • Statistikfelder:
      • feature.num_stats.histograms * vom Typ STANDARD
    • Erkennungsbedingung:
      • Ungefähre Jensen-Shannon-Divergenz, die zwischen der Kontrollstatistik (dh Serving-Statistik für Versatz oder früheren Statistiken für Drift) und der Behandlungsstatistik (dh Trainingsstatistik für Versatz oder aktuelle Statistik für Drift) feature.skew_comparator.jensen_shannon_divergence.threshold > feature.skew_comparator.jensen_shannon_divergence.threshold or feature.drift_comparator.jensen_shannon_divergence.threshold . Die ungefähre Jensen-Shannon-Divergenz wird basierend auf den normalisierten Stichprobenzahlen im num_stats-Standardhistogramm berechnet.
  • NO_DATA_IN_SPAN

    • Anomalietyp in TFDV nicht erkannt
  • SPARSE_FEATURE_MISSING_VALUE

    • Schemafelder:
      • sparse_feature.value_feature
    • Statistikfelder:
      • feature.custom_stats mit „missing_value“ als Name
    • Erkennungsbedingung:
      • missing_value benutzerdefinierte missing_value ! = 0
  • SPARSE_FEATURE_MISSING_INDEX

    • Schemafelder:
      • sparse_feature.index_feature
    • Statistikfelder:
      • feature.custom_stats mit „missing_index“ als Name
    • Erkennungsbedingung:
      • missing_index benutzerdefinierte Status " missing_index enthält einen beliebigen Wert! = 0
  • SPARSE_FEATURE_LENGTH_MISMATCH

    • Schemafelder:
      • sparse_feature.value_feature
      • sparse_feature.index_feature
    • Statistikfelder:
      • feature.custom_stats mit dem Namen "min_length_diff" oder "max_length_diff"
    • Erkennungsbedingung:
      • min_length_diff benutzerdefinierte Status min_length_diff oder max_length_diff enthält einen beliebigen Wert! = 0
  • SPARSE_FEATURE_NAME_COLLISION

    • Schemafelder:
      • sparse_feature.name
      • sparse_feature.lifecycle_stage
      • feature.name
      • feature.lifecycle_stage
    • Erkennungsbedingung:
      • sparse_feature.lifecycle_stage ! = PLANNED , ALPHA , DEBUG oder DEPRECATED und
      • feature.lifecycle_stage ! = PLANNED , ALPHA , DEBUG oder DEPRECATED und
      • sparse_feature.name == feature.name
  • SEMANTIC_DOMAIN_UPDATE

    • Schemafelder:
      • feature.domain_info
    • Statistikfelder:
      • feature.custom_stats mit "domain_info" als Namen
    • Erkennungsbedingung:
      • feature.domain_info ist noch nicht im Schema und festgelegt
      • Für die Funktion gibt es eine einzelne benutzerdefinierte domain_info
  • COMPARATOR_LOW_NUM_EXAMPLES

    • Schemafelder:
      • schema.dataset_constraints.num_examples_drift_comparator.min_fraction_threshold
      • schema.dataset_constraints.num_examples_version_comparator.min_fraction_threshold
    • Statistikfelder:
      • num_examples *
    • Erkennungsbedingung:
      • num_examples > 0 und
      • vorherige Statistik Proto ist verfügbar und
      • num_examples / vorherige Statistik num_examples <Komparator min_fraction_threshold
  • COMPARATOR_HIGH_NUM_EXAMPLES

    • Schemafelder:
      • schema.dataset_constraints.num_examples_drift_comparator.max_fraction_threshold
      • schema.dataset_constraints.num_examples_version_comparator.max_fraction_threshold
    • Statistikfelder:
      • num_examples *
    • Erkennungsbedingung:
      • num_examples > 0 und
      • vorherige Statistik Proto ist verfügbar und
      • num_examples / vorherige Statistiken num_examples > Komparator max_fraction_threshold
  • DATASET_LOW_NUM_EXAMPLES

    • Schemafelder:
      • schema.dataset_constraints.min_examples_count
    • Statistikfelder:
      • num_examples *
    • Erkennungsbedingung:
      • num_examples < dataset_constraints.min_examples_count
  • DATASET_HIGH_NUM_EXAMPLES

    • Schemafelder:
      • schema.dataset_constraints.max_examples_count
    • Statistikfelder:
      • num_examples *
    • Erkennungsbedingung:
      • num_examples > dataset_constraints.max_examples_count
  • WEIGHTED_FEATURE_MISSING_VALUE

    • Schemafelder:
      • weighted_feature.feature
    • Statistikfelder:
      • feature.custom_stats mit „missing_value“ als Name
    • Erkennungsbedingung:
      • missing_value benutzerdefinierte missing_value ! = 0
  • WEIGHTED_FEATURE_MISSING_WEIGHT

    • Schemafelder:
      • weighted_feature.weight_feature
    • Statistikfelder:
      • feature.custom_stats mit „missing_weight“ als Name
    • Erkennungsbedingung:
      • missing_weight benutzerdefinierte stat! = 0
  • WEIGHTED_FEATURE_LENGTH_MISMATCH

    • Schemafelder:
      • weighted_feature.feature
      • weighted_feature.weight_feature
    • Statistikfelder:
      • feature.custom_stats mit dem Namen "min_weighted_length_diff" oder "max_weight_length_diff"
    • Erkennungsbedingung:
      • min_weight_length_diff oder max_weight_length_diff custom stat! = 0
  • WEIGHTED_FEATURE_NAME_COLLISION

    • Schemafelder:
      • weighted_feature.name
      • weighted_feature.lifecycle_stage
      • sparse_feature.name
      • sparse_feature.lifecycle_stage
      • feature.name
      • feature.lifecycle_stage
    • Erkennungsbedingung:
      • weighted_feature.lifecycle_stage ! = PLANNED , ALPHA , DEBUG oder DEPRECATED und entweder:
        • feature.lifecycle_stage ! = PLANNED , ALPHA , DEBUG oder DEPRECATED und weighted_feature.name == feature.name
        • sparse_feature.lifecycle_stage ! = PLANNED , ALPHA , DEBUG oder DEPRECATED und weighted_feature.name == sparse_feature.name
  • VALUE_NESTEDNESS_MISMATCH

    • Schemafelder:
      • feature.value_count
      • feature.value_counts
    • Statistikfelder:
      • feature.common_stats.presence_and_valency_stats
    • Erkennungsbedingung:
      • feature.value_count wird angegeben, und es gibt eine wiederholte presence_and_valency_stats Wertigkeitsstatistik für das Feature (die eine Verschachtelungsstufe angibt, die größer als eins ist).
      • feature.value_counts angegeben ist , und die Anzahl der Male die presence_and_valency für das Feature - Statistik wiederholt wird , nicht die Anzahl der Male entsprechen value_count innerhalb wiederholt feature.value_counts
  • INVALID_FEATURE_SHAPE

    • Schemafelder:
      • feature.shape
    • Statistikfelder:
      • feature.common_stats.num_missing
      • feature.common_stats.min_num_values
      • feature.common_stats.max_num_values
      • feature.common_stats.presence_and_valency_stats.num_missing
      • feature.common_stats.presence_and_valency_stats.min_num_values
      • feature.common_stats.presence_and_valency_stats.max_num_values
      • feature.common_stats.weighted_presence_and_valency_stats
    • Erkennungsbedingung:
      • feature.shape ist angegeben und eine der folgenden:
        • Die Funktion fehlt möglicherweise ( num_missing != 0 ) auf einer bestimmten num_missing != 0 .
        • Die Funktion kann auf einer bestimmten min_num_values != max_num_values eine variable Anzahl von Werten ( min_num_values != max_num_values ) aufweisen
        • Die angegebene Form ist nicht mit den Wertzählungsstatistiken des Features kompatibel. Beispielsweise ist Form [16] kompatibel mit ( min_num_values == max_num_values == [2, 2, 4] (für ein 3-verschachteltes Feature)).
  • DOMAIN_INVALID_FOR_TYPE

    • Schemafelder:

      • feature.type
      • feature.domain_info
    • Statistikfelder:

      • type für jedes Feature ein
    • Erkennungsbedingung:

      • feature.domain_info stimmt nicht mit dem Feature- type int_domain (z. B. wird int_domain angegeben, aber der Feature- type ist float).

      • Das Feature ist in der Statistik vom Typ BYTES aber feature.domain_info ist vom inkompatiblen Typ

  • UNEXPECTED_DATA_TYPE

    • Schemafelder:
      • feature.type
    • Statistikfelder:
      • type für jedes Feature ein
    • Erkennungsbedingung:
      • Der Feature- type nicht dem in feature.type angegebenen Typ
  • FEATURE_MISSING_NAME

    • Schemafelder:
      • feature.name
    • Erkennungsbedingung:
      • feature.name ist nicht angegeben
  • FEATURE_MISSING_TYPE

    • Schemafelder:
      • feature.type
    • Erkennungsbedingung:
      • feature.type ist nicht angegeben
  • INVALID_SCHEMA_SPECIFICATION

    • Schemafelder:
      • feature.domain_info
      • feature.presence.min_fraction
      • feature.value_count.min
      • feature.value_count.max
      • feature.distribution_constraints
    • Erkennungsbedingung:
      • feature.presence.min_fraction <0.0 oder> 1.0
      • feature.value_count.min <0 oder> feature.value_count.max
      • Für ein Feature wird eine bool-, int-, float-, struct- oder semantische Domäne angegeben, und feature.distribution_constraints wird auch für dieses Feature angegeben
      • feature.distribution_constraints ist für ein Feature angegeben, für dieses Feature ist jedoch weder eine Domäne auf feature.string_domain noch feature.string_domain angegeben
  • INVALID_DOMAIN_SPECIFICATION

    • Schemafelder:
      • feature.domain_info
      • feature.bool_domain
      • feature.string_domain
    • Erkennungsbedingung:
      • unbekannter feature.domain_info Typ ist angegeben
      • feature.domain ist angegeben, auf feature.domain ist jedoch keine übereinstimmende Domäne angegeben
      • feature.bool_domain.true_value == feature.bool_domain.false_value
      • wiederholte Werte in feature.string_domain
      • feature.string_domain überschreitet die maximale Größe
  • STATS_NOT_AVAILBLE

    • Eine Anomalie tritt auf, wenn keine Statistiken vorhanden sind, die zur Überprüfung von Einschränkungen erforderlich sind.
  • FEATURE_COVERAGE_TOO_LOW

    • Schemafelder:
      • feature.natural_language_domain.coverage.min_coverage
    • Statistikfelder:
      • NaturalLanguageStatistics.feature_coverage
    • Erkennungsbedingung:
      • NaturalLanguageStatistics.feature_coverage < feature.natural_language_domain.coverage.min_coverage --------------------------------------- -----------------------------------------

* Wenn für dieses Feld eine gewichtete Statistik verfügbar ist, wird diese anstelle der nicht gewichteten Statistik verwendet.