Jakość danych w zmaterializowanych widokach lake

W architekturach medallionów należy wymuszać jakość danych na każdym etapie. Niska jakość danych może prowadzić do nieprawidłowych szczegółowych informacji i nieefektywności operacyjnej.

W tym artykule wyjaśniono, jak zaimplementować kontrolę jakości danych w zmaterializowanych widokach jeziora (MLV) w usłudze Microsoft Fabric.

Implementowanie jakości danych

Ograniczenia na poziomie wiersza walidują każdy wiersz osobno (na przykład "customerName nie jest null na tym wierszu"). Wiele rzeczywistych problemów jakościowych to jednak właściwości kolumny jako całości:

  • Unikalność — klucz główny lub biznesowy, taki jak order_id, nie ma duplikatów.
  • Zupełność — kolumna krytyczna, taka jak customer_id, nie zawiera wartości null.
  • Charakterystyka statystyczna — średnia, rozmiar lub rozkład kolumny mieszczą się w oczekiwanym zakresie.

Wykrycie tych problemów w momencie odświeżania powstrzymuje rozprzestrzenianie się złych danych przez łańcuch brązowo→srebrny→złoty i daje sygnał jakości podlegający audytowi przy każdym uruchomieniu.

Ograniczenia jakości danych na poziomie wiersza

W zmaterializowanych widokach lake (MLV) w Fabric utrzymuj jakość danych, definiując ograniczenia w swoich widokach. Bez jawnych testów drobne problemy z danymi mogą wydłużyć czas przetwarzania lub spowodować awarię przebiegu procesu.

Gdy wiersz narusza ograniczenie, możesz użyć jednego z następujących działań:

  • NIEPOWODZENIE: zaprzestaje odświeżania MLV przy pierwszym naruszeniu ograniczeń. Jest to zachowanie domyślne, nawet jeśli nie określisz FAIL.

  • DROP: kontynuuje przetwarzanie i usuwa rekordy naruszające ograniczenie. Widok dziedziczenia przedstawia liczbę odrzuconych rekordów.

Uwaga / Notatka

Jeśli zdefiniujesz zarówno akcje DROP, jak i FAIL w MLV, akcja FAIL ma pierwszeństwo.

Definiowanie kontroli jakości danych w zmaterializowanym widoku lake

Podczas tworzenia zmaterializowanego widoku jeziora można zdefiniować ograniczenia — reguły jakości danych, które weryfikują każdy wiersz przy odświeżaniu. Ograniczenie to wyrażenie logiczne, które musi być spełnione przez każdy wiersz. Wiersze, które przejdą, są zapisywane w tabeli wyjściowej. „Wiersze, które kończą się niepowodzeniem, są obsługiwane zgodnie z ustawieniem dotyczącym naruszeń: są one odrzucane bez powiadomienia lub powodują niepowodzenie całego procesu odświeżania.”

W poniższym przykładzie zdefiniowano ograniczenie cust_blank, które sprawdza, czy customerName pole nie ma wartości null. Ograniczenie wyklucza wiersze z wartością null customerName z przetwarzania.

CREATE OR REPLACE MATERIALIZED LAKE VIEW IF NOT EXISTS silver.customers_enriched  
(CONSTRAINT cust_blank CHECK (customerName is not null) on MISMATCH DROP)
AS
SELECT
    c.customerID,
    c.customerName,
    c.contact, 
    CASE  
       WHEN COUNT(o.orderID) OVER (PARTITION BY c.customerID) > 0 THEN TRUE  
       ELSE FALSE  
    END AS has_orders 
FROM bronze.customers c LEFT JOIN bronze.orders o 
ON c.customerID = o.customerID;

Funkcje wbudowane systemu

Wbudowane funkcje Spark/SQL, takie jak UPPER(), LOWER(), TRIM(), COALESCE(), INITCAP() i DATE_FORMAT() są w pełni obsługiwane we wszystkich kontekstach MLV zarówno w przypadku odświeżania CREATE, jak i LINEAGE.

CREATE MATERIALIZED LAKE VIEW sample_lakehouse.silver.names (
CONSTRAINT substring_check
CHECK (SUBSTRING(name, 1, 2) = 'Al') ON MISMATCH drop
) AS
SELECT id, name
FROM (VALUES (1, 'Alice'), (2, 'Bob'), (3, 'Ann')) AS t(id, name)

Uwaga / Notatka

Funkcje systemowe to najprostsza i najbardziej niezawodna opcja. Nie wymagają rejestracji, działają we wszystkich kontekstach i są w pełni obsługiwane podczas odświeżania linii danych.

UDF – Zdefiniowane i zarejestrowane w tym samym notesie

UDF zarejestrowane w spark.udf.register() w tym samym notesie są obsługiwane dla polecenia CREATE we wszystkich kontekstach. W przypadku odświeżania POCHODZENIA obsługiwane są tylko konteksty PySpark, ponieważ definicja UDF jest uruchamiana w ramach zaplanowanego wykonywania notesu.

from pyspark.sql import SparkSession
from pyspark.sql.types import StringType
from pyspark.sql.functions import expr

spark = SparkSession.builder.getOrCreate()

# UDF: Extract domain from email
def extract_email_domain(email):
    if email is None or '@' not in email:
        return None
    return email.split('@')[1]

# Registration
spark.udf.register(
    "udf_email_domain",
    extract_email_domain,
    StringType()
)

@fmlv.materialized_lake_view(
    name="udf_testing_silver.mlv_high_value_customers",
    comment="High-value customers identified by UDF criteria",
    table_properties={"delta.enableChangeDataFeed": "true"}
)
def mlv_high_value_customers():
    return spark.sql("""
        SELECT 
            c.customer_id,
            c.name,
            c.email,
            udf_email_domain(c.email) as email_domain,
            c.segment,
            c.lifetime_value,
            total_transactions.total_amount,
            total_transactions.txn_count
        FROM udf_testing_bronze.customers c
        INNER JOIN (
            SELECT 
                customer_id,
                SUM(amount) as total_amount,
                COUNT(*) as txn_count
            FROM udf_testing_bronze.transactions
            WHERE udf_is_positive(amount)
            GROUP BY customer_id
            HAVING SUM(amount) > 1000
        ) total_transactions ON c.customer_id = total_transactions.customer_id
        WHERE udf_validate_customer(c.email, c.age)
            AND c.segment IN ('premium', 'vip')
    """)

print("✓ Created mlv_high_value_customers")

Biblioteki firm trzecich - Pandas UDF

Biblioteki firm trzecich, takie jak UDFy Pandas, umożliwiają implementację reguł jakości danych przy użyciu przetwarzania wektoryzowanego. Umożliwiają one zaawansowane walidacje, takie jak niestandardowa logika biznesowa, kontrole statystyczne lub wykrywanie wzorców, które nie są możliwe w przypadku wbudowanych funkcji. Ułatwia to tworzenie skalowalnych i wielokrotnego użytku ograniczeń jakości danych podczas tworzenia i odświeżania procesu MLV.

  import fmlv
  from pyspark.sql.types import StructType, StructField, IntegerType, TimestampType, StringType, DoubleType, BooleanType
  from datetime import datetime

  import pandas as pd
  from pyspark.sql.types import BooleanType
  def pandas_check_impl(val):
    # Reject if value < median of [100, 200, 300]
    return val >= pd.Series([100, 200, 300]).median()
  spark.udf.register("pandas_check", pandas_check_impl, BooleanType())

  @fmlv.materialized_lake_view(
    name="silver.pyspark_from_two_sqlmlv_inner_pandas",
    comment="PySpark MLV INNER JOIN using pandas-based constraint and DROP violations"
  )
  @fmlv.check(
    name="dq_pandas_check",
    condition="pandas_check(l3)",
    action="DROP"
  )
  def pyspark_from_two_sqlmlv_inner_pandas():
    # Define the function

    # Register the function as a Spark UDF

    # Read source tables
    df1 = spark.table("silver.base_sqlmlv")
    df2 = spark.table("silver.base_sqlmlv")

    # Rename columns for unique join
    df_left = df1.select([df1[col].alias(f"l{i+1}") for i, col in enumerate(df1.columns)])
    df_right = df2.select([df2[col].alias(f"r{i+1}") for i, col in enumerate(df2.columns)])

    # Perform INNER JOIN
    df = df_left.join(df_right, df_left.l1 == df_right.r1, "inner")
    return df


  df = spark.table("silver.pyspark_from_two_sqlmlv_inner_pandas")
  # All amounts should be >= median (200)
  assert all(df.select("l3").rdd.map(lambda r: r[0] >= 200).collect()), "Unexpected low-value rows found"
  print("PySpark MLV INNER JOIN with pandas-based DQ DROP passed")

Biblioteki niestandardowe – pakiet wheel Pythona (.whl)

Funkcje spakowane jako pliki jar lub pliki wheel można zainstalować w klastrze Fabric (za pośrednictwem ustawień środowiska) i używać ich w definicjach uczenia maszynowego. CREATE i LINEAGE REFRESH są obsługiwane w kontekstach PySpark. Aby uzyskać więcej informacji, zobacz Zarządzanie niestandardowymi bibliotekami w środowiskach Fabric.

  %%pyspark
  import fmlv
  from pyspark.sql.types import StructType, StructField, IntegerType, TimestampType, StringType, DoubleType, BooleanType
  from datetime import datetime

  from pyspark.sql.types import BooleanType
  from custom_dq_lib import threshold_check
  def custom_check_impl(val):
    return threshold_check(val, threshold=200)
  spark.udf.register("custom_check", custom_check_impl, BooleanType())

  @fmlv.materialized_lake_view(
    name="silver.pyspark_from_two_sqlmlv_inner_custom_whl",
    comment="PySpark MLV INNER JOIN using custom DQ library and DROP violations",
    replace=True
  )
  @fmlv.check(
    name="dq_custom_check",
    condition="custom_check(l3)",
    action="DROP"
  )
  def pyspark_from_two_sqlmlv_inner_custom():
    # Wrap the custom function as Spark UDF


    # Read source tables
    df1 = spark.table("silver.base_sqlmlv")
    df2 = spark.table("silver.base_sqlmlv")

    # Rename columns for unique join
    df_left = df1.select([df1[col].alias(f"l{i+1}") for i, col in enumerate(df1.columns)])
    df_right = df2.select([df2[col].alias(f"r{i+1}") for i, col in enumerate(df2.columns)])

    # Perform INNER JOIN
    df = df_left.join(df_right, df_left.l1 == df_right.r1, "inner")
    return df


    df = spark.table("silver.pyspark_from_two_sqlmlv_inner_custom_whl")
    # All amounts should be >= threshold (200)
    assert all(df.select("l3").rdd.map(lambda r: r[0] >= 200).collect()), "Unexpected low-value rows found"
    print("PySpark MLV INNER JOIN with custom DQ library passed")

Funkcje danych użytkownika w systemie Fabric

Funkcje użytkownika danych Fabric (UDF) są definiowane centralnie i zarządzane w obszarze roboczym Fabric. Są one dostępne dla dowolnego notesu lub potoku bez konieczności ponownego rejestrowania w każdej sesji, co czyni je idealnym rozwiązaniem dla produkcyjnych potoków uczenia maszynowego. Ta funkcja jest obsługiwana tylko w kontekstach PySpark dla odświeżania CREATE i LINEAGE. Dowiedz się więcej o funkcjach danych użytkownika tutaj. Aby uzyskać więcej informacji, zobacz Omówienie funkcji danych użytkownika Fabric.

  %%pyspark
  import fmlv
  from pyspark.sql import functions as F
  from notebookutils import udf

  myFuncs = udf.getFunctions("UserDataFunction_1")

  def add_greeting_column(df):
    pdf = df.toPandas()
    pdf["greeting"] = pdf["name"].apply(lambda n: myFuncs.hello_fabric(n))
    return spark.createDataFrame(pdf)
  import fmlv
  from pyspark.sql.types import StructType, StructField, IntegerType, StringType, DoubleType

  # -------------------------------------------------------------
  # Define base PySpark MLV (no SQL)
  # -------------------------------------------------------------
  @fmlv.materialized_lake_view(
    name="silver.base_pysparkmlv",
    comment="Base MLV created using PySpark",
    replace=True
  )
  def base_pysparkmlv():

    schema = StructType([
        StructField("id", IntegerType(), True),
        StructField("name", StringType(), True),
        StructField("amount", DoubleType(), True),
        StructField("country", StringType(), True)
    ])

    data = [
        (1, "Alice", 100.0, "US"),
        (2, "Bob", 200.0, "UK"),
        (3, "Charlie", 300.0, "UK")
    ]

    return spark.createDataFrame(data, schema)

  @fmlv.materialized_lake_view(
    name="silver.mlv_udfn_null_test",
    replace=False
  )
  @fmlv.check(
    name="null_check",
    condition="greeting IS NOT NULL",
    action="FAIL"
  )
  def mlv_udfn_null_test():
    df = spark.table("silver.base_pysparkmlv")
    return add_greeting_column(df)

Kontrole jakości danych na poziomie kolumn

Jak to działa

Zdefiniuj sprawdzanie jakości danych na poziomie kolumn (DQ) za pomocą trzech dekoratorów Python, które umieszczasz w komórce notesu, oddzielnie od definicji MLV:

Dekorator Purpose
@fmlv.dq_suite(mlv_name=…) Rejestruje pakiet jakości danych względem nazwanego, istniejącego MLV i ładuje jego dane, na których zostaną uruchomione kontrole.
@fmlv.validate("<fn>", "FAIL"\|"WARN") Wykonuje test walidacyjny z wynikiem pozytywnym/negatywnym oraz wybranym działaniem (patrz Kontroluj wynik poniżej).
@fmlv.analyze("<fn>") Wykonuje przejście profilowania, które oblicza metryki kolumnowe (rozmiar, zupełność, średnia, ...). Generuje tylko metryki — nigdy nie powoduje niepowodzenia uruchomienia.

Ponieważ pakiet odwołuje się do MLV po nazwie, jakość danych może mieć właściciela, być uruchamiana i planowana niezależnie od definicji MLV — a także można wykonywać kontrole bez wywoływania odświeżania.

Krok 1: Skonfiguruj środowisko uruchomieniowe

Skonfiguruj zależności dla wersji Fabric runtime przed definiowaniem kontroli jakości danych na poziomie kolumn.

Środowisko uruchomieniowe Fabric wcześniejsze niż 2.0

Pobierz pakiet wheel PyDeequ 1.7.0 i prześlij go jako niestandardową bibliotekę w swoim środowisku Fabric. Instrukcje można znaleźć w artykule Przekazywanie niestandardowych bibliotek.

Fabric runtime 2.0 lub nowszy

Dodaj następujące właściwości Spark:

Właściwość Spark Value
spark.driver.extraClassPath /opt/deequ/jars/*
spark.executor.extraClassPath /opt/deequ/jars/*

Możesz dodać te właściwości zarówno w środowisku, jak i w notatniku:

Krok 2: Zdefiniuj sprawdzenia na poziomie poszczególnych kolumn

W tym przykładzie zdefiniuj kontrole jakości danych na poziomie kolumn dla materializowanego widoku lake sales_db.daily_orders, określonego przez mlv_name w @fmlv.dq_suite.

Umieść rejestrację zestawu i jego funkcje wejściowe w jednej komórce jakości danych. Poniższy przykład wykonuje dwie kontrole w jednym przejściu walidacyjnym — customer_id musi być kompletne (bez nullów) i order_id musi być unikalny:

import os
os.environ["SPARK_VERSION"] = "3.5"   # works on both 3.5 and 4.1
import fmlv

# Entry function — returns a PyDeequ VerificationResult DataFrame
def completeness_and_uniqueness(df):
    from pydeequ.checks import Check, CheckLevel
    from pydeequ.verification import VerificationSuite, VerificationResult

    check = Check(spark, CheckLevel.Error, "Completeness & Uniqueness")
    result = (
        VerificationSuite(spark)
        .onData(df)
        .addCheck(
            check.isComplete("customer_id")   # check 1: no nulls
                 .isUnique("order_id")        # check 2: no duplicates
        )
        .run()
    )
    return VerificationResult.checkResultsAsDataFrame(spark, result)
# Data quality cell — separate from the MLV definition
@fmlv.dq_suite(mlv_name="sales_db.daily_orders", replace=True)
@fmlv.validate("completeness_and_uniqueness", "FAIL")
def daily_orders_dq():
    pass

Dodaj metryki bez niepowodzenia uruchomienia. Dodaj przebieg @fmlv.analyze, aby obliczyć metryki kolumnowe (rozmiar, zupełność, średnia, ...) na potrzeby obserwowalności. Wyniki analizy są zawsze rejestrowane i nigdy nie blokują przebiegu — przydatne, gdy reguły walidacji wciąż się rozwijają.

import os
os.environ["SPARK_VERSION"] = "3.5"   # works on both 3.5 and 4.1
import fmlv

# Entry function — returns a PyDeequ AnalyzerContext metrics DataFrame
def column_profiling(df):
    from pydeequ.analyzers import AnalysisRunner, AnalyzerContext, Size, Completeness, Mean
    result = (
        AnalysisRunner(spark)
        .onData(df)
        .addAnalyzer(Size())
        .addAnalyzer(Completeness("customer_id"))
        .addAnalyzer(Mean("amount"))
        .run()
    )
    return AnalyzerContext.successMetricsAsDataFrame(spark, result)
# Data quality cell — separate from the MLV definition
@fmlv.dq_suite(mlv_name="sales_db.daily_orders", replace=True)
@fmlv.validate("completeness_and_uniqueness", "FAIL")
@fmlv.analyze("column_profiling")
def daily_orders_dq():
    pass
Sterowanie wynikiem: NIEPOWODZENIE w porównaniu z OSTRZEŻENIEM

Akcja na @fmlv.validate decyduje, co się dzieje, gdy test się nie powiedzie:

  • FAIL — niepowodzenie sprawdzenia powoduje niepowodzenie uruchomienia kontroli jakości danych i blokuje kolejne MLV, które od niego zależą. Używaj go do ścisłych ograniczeń, takich jak klucze główne i pola obowiązkowe.
  • WARN — awaria jest rejestrowana, ale uruchomienie nadal kończy się powodzeniem, a podrzędne MLV nie są blokowane. Używaj go do miękkich lub zalecających reguł.

Krok 3: Włącz kontrole jakości danych w harmonogramie

Wybierz, czy kontrole na poziomie kolumn są wykonywane jako część harmonogramu odświeżania. W zaawansowanych ustawieniach na ekranie Utwórz nowy harmonogram rozwijane menu Sprawdzanie jakości danych oferuje dwie opcje:

  • Sprawdź po każdym uruchomieniu — zestaw jakości danych uruchamia się automatycznie po zakończeniu każdego odświeżenia MLV w tym harmonogramie.
  • Brak kontroli — jakość danych jest pomijana w tym harmonogramie; MLV nadal odświeża swój rytm.

Zrzut ekranu z opcji Utwórz nowy harmonogram Zaawansowane ustawienia z rozwijanym menu sprawdzania jakości danych ustawionym na Sprawdzaj po każdym uruchomieniu.

Ustawienie Kontrola jakości danych w ustawieniach Zaawansowanych harmonogramu — wybierz Sprawdź po każdym uruchomieniu lub Brak sprawdzania.

Jak nieudana kontrola wpływa na pipeline

W widoku pochodzenia danych kontrola jakości danych dla gold.daily_dq_reportusage została zdefiniowana za pomocą FAIL i zakończyła się niepowodzeniem. W rezultacie jego zależny element podrzędny, gold.monthly_dq_report…, jest automatycznie Pominięty, podczas gdy niezależne gałęzie (gold.expected_regions, gold.region_mlv_dq_rep…) kończą się normalnie.

Zrzut ekranu widoku linii linii pokazujący węzeł DataQuality zakończony niepowodzeniem, blokujący swój zależny węzeł podrzędny, który jest pomijany, podczas gdy gałęzie równorzędne są zakończone.

FAIL Kontrola jakości danych zatrzymuje łańcuch — pomijany jest element zależny znajdujący się dalej w łańcuchu od nieudanego węzła, ale niezależne gałęzie są kontynuowane.

Kolejność wykonywania. Gdy zestaw ma oba typy, wszystkie @fmlv.validate funkcje uruchamiają się najpierw (w kolejności definicji), a następnie wszystkie @fmlv.analyze funkcje. Nieudana kontrola jest rejestrowana i wykonywanie jest kontynuowane; o ogólnym wyniku decyduje się po zakończeniu wszystkich kontroli — przebieg kończy się niepowodzeniem tylko wtedy, gdy kontrola działania FAIL się nie powiodła.

Krok 4: Przeglądaj i analizuj raport jakości danych

Historia uruchomienia pokazuje, czy jakość danych była włączona czy wyłączona dla każdego wykonania. Możesz też uruchomić pakiet na żądanie z jego notatnika w dowolnym momencie, niezależnie od odświeżania.

Wybierz dowolny węzeł MLV w widoku pochodzenia danych i otwórz kartę Jakość danych w panelu szczegółów, aby zobaczyć wyniki tego uruchomienia:

  • Metryki obliczone — agregowane metryki na poziomie kolumn obliczane przez analizatory Deequ (na przykład Completeness z region).
  • Wyniki weryfikacji — podsumowanie łącznej liczby kontroli, łącznej liczby zakończonych powodzeniem i łącznej liczby nieudanych, a następnie każdego ograniczenia oraz jego statusu zaliczenia/niepowodzenia, dzięki czemu można dokładnie zobaczyć, która reguła zakończyła się powodzeniem, a która nie.

Zrzut ekranu panelu szczegółów jakości danych pokazujący obliczone metryki i wyniki weryfikacji ze statusem zaliczenia/niezaliczenia dla każdego ograniczenia.

Zakładka Jakość Danych pokazuje obliczone metryki oraz wyniki weryfikacji dla każdego ograniczenia dla wybranego uruchomienia MLV.

Historia uruchomienia MLV pokazuje również status jakości danych dla każdego uruchomienia — Sukces, Niepowodzenie lub brak wskaźnika, gdy żaden zestaw nie uruchomił się — dzięki czemu można od razu rozpoznać problematyczne uruchomienia bez otwierania każdego węzła.

Wspierane kontrole i analizatory

Ponieważ DQ na poziomie kolumnowym jest zasilane przez otwartoźródłową bibliotekę Deequ, możesz korzystać ze wszystkich kontroli i analizatorów Deequ w swoich funkcjach wejściowych. Sprawdzenia walidacyjne (używane z @fmlv.validate) to Check ograniczenia generujące wynik zaliczenia/niezdania; analizatory (używane z @fmlv.analyze) obliczają metrykę bez zaliczenia/niezaliczenia. Najczęściej spotykane są wymienione w poniższych tabelach.

Kontrole walidacyjne — @fmlv.validate
Sprawdź Description Example
hasSize Liczba wierszy w widoku spełnia warunek. .hasSize(lambda s: s == 5)
isComplete Kolumna nie zawiera wartości null. .isComplete("customer_id")
hasCompleteness Ułamek wartości innych niż null spełnia próg. .hasCompleteness("email", lambda c: c >= 0.9)
isUnique Kolumna nie zawiera zduplikowanych wartości. .isUnique("order_id")
hasUniqueness Odsetek unikalnych wartości spełnia pewien warunek. .hasUniqueness(["brand"], lambda u: u == 1.0)
hasDistinctness Odsetek różnych wartości spełnia warunek. .hasDistinctness(["title"], lambda d: d > 0.5)
isPrimaryKey Kolumna (lub zestaw kolumn) jednoznacznie identyfikuje każdy wiersz. .isPrimaryKey("order_id")
isContainedIn Wszystkie wartości mieszczą się w dozwolonym zbiorze. .isContainedIn("priority", ["high", "low"])
isNonNegative / isPositive Kolumna nie zawiera wartości ujemnych / zawiera tylko wartości ściśle dodatnie. .isNonNegative("num_views")
isLessThan / isGreaterThan Jedna kolumna jest konsekwentnie mniejsza / większa od innej. .isLessThan("discount", "price")
hasMin / hasMax Minimum/maksimum kolumny spełnia pewien warunek. .hasMax("age", lambda v: v <= 120)
hasMean / hasSum Średnia kolumnowa / suma spełnia warunek. .hasSum("total_votes", lambda v: v > 0)
hasStandardDeviation Odchylenie standardowe kolumny spełnia warunek. .hasStandardDeviation("amount", lambda v: v < 5)
hasApproxQuantile Przybliżony kwantyl (na przykład mediana) spełnia warunek. .hasApproxQuantile("num_views", 0.5, lambda v: v <= 10)
hasCorrelation Korelacja Pearsona między dwiema kolumnami spełnia pewien warunek. .hasCorrelation("a", "b", lambda c: c > 0.8)
hasNumberOfDistinctValues Liczba unikalnych wartości spełnia pewien warunek. .hasNumberOfDistinctValues("locale", lambda n: n == 5)
hasEntropy Zawartość informacji (entropia) kolumny spełnia pewien warunek. .hasEntropy("locale", lambda e: e > 2.0)
hasDataType Wartości odpowiadają oczekiwanemu typowi danych. .hasDataType("id", ConstrainableDataTypes.Integral)
hasPattern / containsURL / containsEmail Ułamek wartości odpowiadających regexowi / URL-owi / wzorcowi e-mail spełnia pewien warunek. .containsURL("description", lambda c: c >= 0.5)
containsCreditCardNumber / containsSocialSecurityNumber Odsetek wartości odpowiadających wzorowi karty kredytowej / SSN spełnia pewien warunek. .containsCreditCardNumber("notes", lambda c: c == 0)
satisfies Odsetek wierszy spełniający niestandardowy predykat SQL spełnia warunek. .satisfies("age >= 18", "adults", lambda c: c == 1.0)
Analizatory / metryki — @fmlv.analyze
Metric Description Example
ApproxCountDistinct Przybliżona liczba różnych wartości, obliczona za pomocą szkiców HyperLogLog++. ApproxCountDistinct("product_id")
ApproxQuantile Przybliżona kwantyla rozkładu. ApproxQuantile("locale_encoded", 0.5)
ApproxQuantiles Kilka przybliżonych kwantyli rozkładu. ApproxQuantiles("locale_encoded", [0.1, 0.5, 0.9])
Completeness Ułamek niepustych wartości w kolumnie. Completeness("product_id")
Compliance Ułamek wierszy spełniających dane ograniczenie kolumnowe. Compliance("locale", "locale in ('es','jp','us')")
Correlation Korelacja Pearsona między dwiema kolumnami, w zakresie [-1, 1]. Correlation("title", "brand")
CountDistinct Liczba różnych wartości. CountDistinct("locale")
DataType Rozkład typów danych (logiczny, ułamkowy, całkowity, ciąg znaków). DataType("locale")
Distinctness Ułamek różnych wartości do całkowitej liczby wartości. Distinctness("title")
Entropy Zawartość informacji w rozkładzie wartości kolumny, mierzona w natach. Entropy("locale_encoded")
Maximum / Minimum Maksymalna / minimalna wartość kolumny. Maximum("locale_encoded")
Mean Wartość średnia; wartości null są wyłączone. Mean("locale_encoded")
MutualInformation Ile informacji o jednej kolumnie można wywnioskować z innej; jest symetryczna i nieujemna. MutualInformation(["title", "brand"])
PatternMatch Odsetek wierszy pasujących do danego wyrażenia regularnego. PatternMatch("locale", r"\w{2}")
Size Liczba wierszy w DataFrame. Size()
Sum Suma wszystkich wartości kolumny. Sum("total_votes")
UniqueValueRatio Ułamek unikalnych wartości przez liczbę wszystkich różnych wartości. UniqueValueRatio(["brand"])
Uniqueness Ułamek unikalnych wartości w stosunku do liczby wszystkich wartości. Uniqueness(["brand"])

Otwartoźródłowa biblioteka Deequ zapewnia te kontrole i analizatory. Pełną i autorytatywną listę można znaleźć w projekcie Deequ pod adresem github.com/awslabs/deequ.

Summary

  1. Stwórz swój MLV i zanotuj jego w pełni kwalifikowaną nazwę.
  2. W osobnej komórce jakości danych zarejestruj zestaw za pomocą @fmlv.dq_suite(mlv_name=…).
  3. Dodaj kontrole — łącz @fmlv.validate("<fn>", "FAIL"|"WARN") i/lub @fmlv.analyze("<fn>") i zapisuj odpowiadające funkcje wejściowe zwracające ramki danych PyDeequ.
  4. Uruchom go — na żądanie z notatnika lub włącz przełącznik jakości danych podczas tworzenia harmonogramu.
  5. Przeglądaj wyniki na karcie Jakość danych oraz w historii przebiegów.