Notatka
Dostęp do tej strony wymaga autoryzacji. Może spróbować zalogować się lub zmienić katalogi.
Dostęp do tej strony wymaga autoryzacji. Możesz spróbować zmienić katalogi.
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:
- Środowisko: Dodaj właściwości w obszarze Spark Compute>właściwości platformy Spark, a następnie zapisz i opublikuj środowisko. Instrukcje można znaleźć w artykule Dodaj konfiguracje Spark do środowiska niestandardowego.
-
Notatnik: Dodaj właściwości do obiektu
confw poleceniu%%configurew pierwszej komórce kodu, zanim rozpoczniesz sesję Spark. Instrukcje można znaleźć w artykule Magiczne polecenie konfiguracji sesji Spark.
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.
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.
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
Completenesszregion). - 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.
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
- Stwórz swój MLV i zanotuj jego w pełni kwalifikowaną nazwę.
-
W osobnej komórce jakości danych zarejestruj zestaw za pomocą
@fmlv.dq_suite(mlv_name=…). -
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. - Uruchom go — na żądanie z notatnika lub włącz przełącznik jakości danych podczas tworzenia harmonogramu.
- Przeglądaj wyniki na karcie Jakość danych oraz w historii przebiegów.
Treści powiązane
- Jakość danych w Materialized Lake Views — Microsoft Learn
- Przegląd Materialized Lake Views — Microsoft Learn
- Dokumentacja DeeQu