Självstudie: Validera data med SemPy och stora förväntningar (GX)
I den här självstudien får du lära dig hur du använder SemPy tillsammans med GX (Great Expectations ) för att utföra dataverifiering på Power BI-semantiska modeller.
I den här självstudiekursen lär du dig att:
- Verifiera begränsningar för en datauppsättning på din Infrastruktur-arbetsyta med Great Expectations infrastrukturdatakälla (byggd på semantisk länk).
- Konfigurera en GX-datakontext, datatillgångar och förväntningar.
- Visa valideringsresultat med en GX-kontrollpunkt.
- Använd semantisk länk för att analysera rådata.
Förutsättningar
Skaffa en Microsoft Fabric-prenumeration. Eller registrera dig för en kostnadsfri utvärderingsversion av Microsoft Fabric.
Logga in på Microsoft Fabric.
Använd upplevelseväxlaren till vänster på startsidan för att växla till Synapse Datavetenskap upplevelse.
- Välj Arbetsytor i det vänstra navigeringsfönstret för att hitta och välja din arbetsyta. Den här arbetsytan blir din aktuella arbetsyta.
- Ladda ned PBIX.pbix-filen Exempel på detaljhandelsanalys.
- På din arbetsyta använder du knappen Ladda upp för att ladda upp PBIX.pbix-filen Exempel på detaljhandelsanalys till arbetsytan.
Följ med i notebook-filen
great_expectations_tutorial.ipynb är anteckningsboken som medföljer den här självstudien.
Om du vill öppna den medföljande notebook-filen för den här självstudien följer du anvisningarna i Förbereda systemet för självstudier för datavetenskap för att importera anteckningsboken till din arbetsyta.
Om du hellre vill kopiera och klistra in koden från den här sidan kan du skapa en ny notebook-fil.
Se till att bifoga ett lakehouse i notebook-filen innan du börjar köra kod.
Konfigurera anteckningsboken
I det här avsnittet konfigurerar du en notebook-miljö med nödvändiga moduler och data.
- Installera
SemPy
och relevantaGreat Expectations
bibliotek från PyPI med hjälp av%pip
in-line-installationsfunktionen i notebook-filen.
# install libraries
%pip install semantic-link great-expectations great_expectations_experimental great_expectations_zipcode_expectations
# load %%dax cell magic
%load_ext sempy
- Utför nödvändiga importer av moduler som du behöver senare:
import great_expectations as gx
from great_expectations.expectations.expectation import ExpectationConfiguration
from great_expectations_zipcode_expectations.expectations import expect_column_values_to_be_valid_zip5
Konfigurera GX-datakontext och datakälla
För att komma igång med Stora förväntningar måste du först konfigurera en GX-datakontext. Kontexten fungerar som en startpunkt för GX-åtgärder och innehåller alla relevanta konfigurationer.
context = gx.get_context()
Nu kan du lägga till din Fabric-datauppsättning i den här kontexten som en datakälla för att börja interagera med data. I den här självstudien används en standardfil för Power BI-exempelsemantikmodellen Retail Analysis Sample .pbix.
ds = context.sources.add_fabric_powerbi("Retail Analysis Data Source", dataset="Retail Analysis Sample PBIX")
Ange datatillgångar
Definiera Datatillgångar för att ange den delmängd av data som du vill arbeta med. Tillgången kan vara så enkel som fullständiga tabeller eller vara lika komplex som en anpassad DAX-fråga (Data Analysis Expressions).
Här lägger du till flera tillgångar:
- Power BI-tabell
- Power BI-mått
- Anpassad DAX-fråga
- DMV-fråga (Dynamic Management View )
Power BI-tabell
Lägg till en Power BI-tabell som en datatillgång.
ds.add_powerbi_table_asset("Store Asset", table="Store")
Power BI-mått
Om datauppsättningen innehåller förkonfigurerade mått lägger du till måtten som tillgångar efter ett liknande API som SemPys evaluate_measure
.
ds.add_powerbi_measure_asset(
"Total Units Asset",
measure="TotalUnits",
groupby_columns=["Time[FiscalYear]", "Time[FiscalMonth]"]
)
DAX
Om du vill definiera egna mått eller ha mer kontroll över specifika rader kan du lägga till en DAX-tillgång med en anpassad DAX-fråga. Här definierar vi ett Total Units Ratio
mått genom att dela upp två befintliga mått.
ds.add_powerbi_dax_asset(
"Total Units YoY Asset",
dax_string=
"""
EVALUATE SUMMARIZECOLUMNS(
'Time'[FiscalYear],
'Time'[FiscalMonth],
"Total Units Ratio", DIVIDE([Total Units This Year], [Total Units Last Year])
)
"""
)
DMV-fråga
I vissa fall kan det vara bra att använda DMV-beräkningar (Dynamic Management View ) som en del av dataverifieringsprocessen. Du kan till exempel hålla reda på antalet överträdelser av referensintegritet i din datauppsättning. Mer information finns i Rensa data = snabbare rapporter.
ds.add_powerbi_dax_asset(
"Referential Integrity Violation",
dax_string=
"""
SELECT
[Database_name],
[Dimension_Name],
[RIVIOLATION_COUNT]
FROM $SYSTEM.DISCOVER_STORAGE_TABLES
"""
)
Förväntningar
Om du vill lägga till specifika begränsningar i tillgångarna måste du först konfigurera Expectation Suites. När du har lagt till enskilda förväntningar i varje svit kan du uppdatera datakontexten som konfigurerats i början med den nya sviten. En fullständig lista över tillgängliga förväntningar finns i galleriet för GX-förväntningar.
Börja med att lägga till en "Retail Store Suite" med två förväntningar:
- ett giltigt postnummer
- en tabell med radantal mellan 80 och 200
suite_store = context.add_expectation_suite("Retail Store Suite")
suite_store.add_expectation(ExpectationConfiguration("expect_column_values_to_be_valid_zip5", { "column": "PostalCode" }))
suite_store.add_expectation(ExpectationConfiguration("expect_table_row_count_to_be_between", { "min_value": 80, "max_value": 200 }))
context.add_or_update_expectation_suite(expectation_suite=suite_store)
TotalUnits
Åtgärd
Lägg till en "Retail Measure Suite" med en förväntan:
- Kolumnvärdena ska vara större än 50 000
suite_measure = context.add_expectation_suite("Retail Measure Suite")
suite_measure.add_expectation(ExpectationConfiguration(
"expect_column_values_to_be_between",
{
"column": "TotalUnits",
"min_value": 50000
}
))
context.add_or_update_expectation_suite(expectation_suite=suite_measure)
Total Units Ratio
DAX
Lägg till en "Retail DAX Suite" med en förväntan:
- Kolumnvärden för Total Units Ratio ska vara mellan 0,8 och 1,5
suite_dax = context.add_expectation_suite("Retail DAX Suite")
suite_dax.add_expectation(ExpectationConfiguration(
"expect_column_values_to_be_between",
{
"column": "[Total Units Ratio]",
"min_value": 0.8,
"max_value": 1.5
}
))
context.add_or_update_expectation_suite(expectation_suite=suite_dax)
Överträdelser av referensintegritet (DMV)
Lägg till en "Retail DMV Suite" med en förväntan:
- RIVIOLATION_COUNT ska vara 0
suite_dmv = context.add_expectation_suite("Retail DMV Suite")
# There should be no RI violations
suite_dmv.add_expectation(ExpectationConfiguration(
"expect_column_values_to_be_in_set",
{
"column": "RIVIOLATION_COUNT",
"value_set": [0]
}
))
context.add_or_update_expectation_suite(expectation_suite=suite_dmv)
Validering
Om du vill köra de angivna förväntningarna mot data skapar du först en kontrollpunkt och lägger till den i kontexten. Mer information om kontrollpunktskonfiguration finns i arbetsflödet för dataverifiering.
checkpoint_config = {
"name": f"Retail Analysis Checkpoint",
"validations": [
{
"expectation_suite_name": "Retail Store Suite",
"batch_request": {
"datasource_name": "Retail Analysis Data Source",
"data_asset_name": "Store Asset",
},
},
{
"expectation_suite_name": "Retail Measure Suite",
"batch_request": {
"datasource_name": "Retail Analysis Data Source",
"data_asset_name": "Total Units Asset",
},
},
{
"expectation_suite_name": "Retail DAX Suite",
"batch_request": {
"datasource_name": "Retail Analysis Data Source",
"data_asset_name": "Total Units YoY Asset",
},
},
{
"expectation_suite_name": "Retail DMV Suite",
"batch_request": {
"datasource_name": "Retail Analysis Data Source",
"data_asset_name": "Referential Integrity Violation",
},
},
],
}
checkpoint = context.add_checkpoint(
**checkpoint_config
)
Kör nu kontrollpunkten och extrahera resultatet som en Pandas DataFrame för enkel formatering.
result = checkpoint.run()
Bearbeta och skriv ut dina resultat.
import pandas as pd
data = []
for run_result in result.run_results:
for validation_result in result.run_results[run_result]["validation_result"]["results"]:
row = {
"Batch ID": run_result.batch_identifier,
"type": validation_result.expectation_config.expectation_type,
"success": validation_result.success
}
row.update(dict(validation_result.result))
data.append(row)
result_df = pd.DataFrame.from_records(data)
result_df[["Batch ID", "type", "success", "element_count", "unexpected_count", "partial_unexpected_list"]]
Från dessa resultat kan du se att alla dina förväntningar klarade valideringen, förutom den "Totala antalet enheters yoy-tillgång" som du definierade via en anpassad DAX-fråga.
Diagnostik
Med hjälp av semantisk länk kan du hämta källdata för att förstå vilka exakta år som ligger utom räckhåll. Semantisk länk ger en infogad magi för att köra DAX-frågor. Använd semantisk länk för att köra samma fråga som du skickade till GX-datatillgången och visualisera de resulterande värdena.
%%dax "Retail Analysis Sample PBIX"
EVALUATE SUMMARIZECOLUMNS(
'Time'[FiscalYear],
'Time'[FiscalMonth],
"Total Units Ratio", DIVIDE([Total Units This Year], [Total Units Last Year])
)
Spara dessa resultat i en DataFrame.
df = _
Rita resultatet.
import matplotlib.pyplot as plt
df["Total Units % Change YoY"] = (df["[Total Units Ratio]"] - 1)
df.set_index(["Time[FiscalYear]", "Time[FiscalMonth]"]).plot.bar(y="Total Units % Change YoY")
plt.axhline(0)
plt.axhline(-0.2, color="red", linestyle="dotted")
plt.axhline( 0.5, color="red", linestyle="dotted")
None
Från diagrammet kan du se att april och juli var något utom räckhåll och sedan kan vidta ytterligare åtgärder för att undersöka.
Lagra GX-konfiguration
När data i datamängden ändras över tid kanske du vill köra GX-valideringarna igen som du precis har utfört. För närvarande lever datakontexten (som innehåller de anslutna datatillgångarna, förväntanssviterna och kontrollpunkten) tillfälliga, men den kan konverteras till en filkontext för framtida användning. Du kan också instansiera en filkontext (se Instansiera en datakontext).
context = context.convert_to_file_context()
Nu när du har sparat kontexten kopierar gx
du katalogen till ditt lakehouse.
Viktigt!
Den här cellen förutsätter att du har lagt till ett lakehouse i notebook-filen. Om det inte finns någon bifogad lakehouse visas inget fel, men du kommer inte heller senare att kunna hämta kontexten. Om du lägger till ett lakehouse nu startas kerneln om, så du måste köra hela notebook-filen igen för att komma tillbaka till den här punkten.
# copy GX directory to attached lakehouse
!cp -r gx/ /lakehouse/default/Files/gx
Nu kan framtida kontexter skapas med context = gx.get_context(project_root_dir="<your path here>")
för att använda alla konfigurationer från den här självstudien.
I en ny notebook-fil bifogar du till exempel samma lakehouse och använder context = gx.get_context(project_root_dir="/lakehouse/default/Files/gx")
för att hämta kontexten.
Relaterat innehåll
Kolla in andra självstudier för semantisk länk/SemPy:
- Självstudie: Rensa data med funktionella beroenden
- Självstudie: Analysera funktionella beroenden i en exempelsemantisk modell
- Självstudie: Extrahera och beräkna Power BI-mått från en Jupyter-anteckningsbok
- Självstudie: Identifiera relationer i en semantisk modell med hjälp av semantisk länk
- Självstudie: Identifiera relationer i Synthea-datauppsättningen med hjälp av semantisk länk