Zelfstudie: Functionele afhankelijkheden in een semantisch model analyseren

In deze zelfstudie bouwt u voort op eerder werk dat is uitgevoerd door een Power BI-analist en opgeslagen in de vorm van semantische modellen (Power BI-gegevenssets). Met behulp van SemPy (preview) in de Synapse Data Science-ervaring in Microsoft Fabric analyseert u functionele afhankelijkheden die bestaan in kolommen van een DataFrame. Deze analyse helpt bij het detecteren van problemen met niet-triviale gegevenskwaliteit om nauwkeurigere inzichten te verkrijgen.

In deze zelfstudie leert u het volgende:

• Pas domeinkennis toe om hypothesen te formuleren over functionele afhankelijkheden in een semantisch model.
• Vertrouwd raken met onderdelen van de Python-bibliotheek van semantische koppelingen (SemPy) die ondersteuning bieden voor integratie met Power BI en helpen bij het automatiseren van analyse van gegevenskwaliteit. Deze onderdelen zijn onder andere:
  • FabricDataFrame- een pandas-achtige structuur die is uitgebreid met aanvullende semantische informatie.
  • Handige functies voor het ophalen van semantische modellen uit een Fabric-werkruimte in uw notebook.
  • Nuttige functies die de evaluatie van hypothesen over functionele afhankelijkheden automatiseren en waarmee schendingen van relaties in uw semantische modellen worden geïdentificeerd.

Voorwaarden

• Een Microsoft Fabric-abonnementophalen. Of meld u aan voor een gratis microsoft Fabric-proefversie.

• Meld u aan bij Microsoft Fabric-.

• Gebruik de ervaringswisselaar aan de linkerkant van de startpagina om over te schakelen naar Fabric.

  

• Selecteer Werkruimten in het linkernavigatiedeelvenster om uw werkruimte te zoeken en te selecteren. Deze werkruimte wordt uw huidige werkruimte.

• Download het Customer Profitability Sample.pbix semantic model uit de GitHub-opslagplaats fabric-samples.

• Selecteer in uw werkruimte Importeren>rapport of gepagineerd rapport>van deze computer om het bestand Customer Profitability Sample.pbix te uploaden naar uw werkruimte.

Volg mee in het notitieblok

Het notitieboek powerbi_dependencies_tutorial.ipynb inspireert deze zelfstudie.

• Als u het bijbehorende notitieblok voor deze zelfstudie wilt openen, volgt u de instructies in Uw systeem voorbereiden op zelfstudies voor gegevenswetenschap om het notebook in uw werkruimte te importeren.

• Als u liever de code van deze pagina kopieert en plakt, kunt u een nieuw notitieblok maken.

• Zorg ervoor dat een lakehouse aan het notebook koppelen voordat u begint met het uitvoeren van code.

Het notebook instellen

In deze sectie stelt u een notebookomgeving in met de benodigde modules en gegevens.

1. Installeer SemPy vanuit PyPI met behulp van de %pip inline-installatiemogelijkheid in het notebook:

   %pip install semantic-link
   

2. Voer de benodigde importbewerkingen uit van modules die u later nodig hebt:

   import sempy.fabric as fabric
   from sempy.dependencies import plot_dependency_metadata
   

De gegevens laden en vooraf verwerken

In deze zelfstudie wordt gebruikgemaakt van een standaard semantisch voorbeeldmodel Customer Profitability Sample.pbix. Zie voorbeeld van klantwinstgevendheid voor Power BIvoor een beschrijving van het semantische model.

1. Laad de Power BI-gegevens in FabricDataFrames met behulp van de read_table functie van SemPy:

   dataset = "Customer Profitability Sample"
   customer = fabric.read_table(dataset, "Customer")
   customer.head()
   

2. Laad de State tabel in een FabricDataFrame:

   state = fabric.read_table(dataset, "State")
   state.head()
   

   Hoewel de uitvoer van deze code eruitziet als een Pandas DataFrame, hebt u in feite een gegevensstructuur geïnitialiseerd, een FabricDataFrame die enkele nuttige bewerkingen boven op pandas ondersteunt.

3. Controleer het gegevenstype van customer:

   type(customer)
   

   De uitvoer bevestigt dat customer van het type sempy.fabric._dataframe._fabric_dataframe.FabricDataFrameis.'

4. Voeg customer en state DataFrames samen.

   customer_state_df = customer.merge(state, left_on="State", right_on="StateCode",  how='left')
   customer_state_df.head()
   

Functionele afhankelijkheden identificeren

Een functionele afhankelijkheid manifesteert zich als een een-op-veel-relatie tussen de waarden in twee (of meer) kolommen binnen een DataFrame. Deze relaties kunnen worden gebruikt om problemen met gegevenskwaliteit automatisch te detecteren.

1. Voer de find_dependencies functie van SemPy uit op het samengevoegde DataFrame om bestaande functionele afhankelijkheden tussen waarden in de kolommen te identificeren:

   dependencies = customer_state_df.find_dependencies()
   dependencies
   

2. Visualiseer de geïdentificeerde afhankelijkheden met behulp van de plot_dependency_metadata functie van SemPy:

   plot_dependency_metadata(dependencies)
   

   

   Zoals verwacht laat de grafiek met functionele afhankelijkheden zien dat de kolom Customer enkele kolommen zoals City, Postal Codeen Namebepaalt.

   Verrassend genoeg toont de grafiek geen functionele afhankelijkheid tussen City en Postal Code, waarschijnlijk omdat er veel schendingen zijn in de relaties tussen de kolommen. U kunt de functie plot_dependency_violations van SemPy gebruiken om schendingen van afhankelijkheden tussen specifieke kolommen te visualiseren.

De gegevens voor kwaliteitsproblemen verkennen

1. Teken een grafiek met de plot_dependency_violations visualisatiefunctie van SemPy.

   customer_state_df.plot_dependency_violations('Postal Code', 'City')
   

   

   In de plot met afhankelijkheidsschendingen ziet u waarden voor Postal Code aan de linkerkant en waarden voor City aan de rechterkant. Een rand verbindt een Postal Code aan de linkerkant met een City aan de rechterkant als er een rij is met deze twee waarden. De randen worden geannoteerd met het aantal van dergelijke rijen. Er zijn bijvoorbeeld twee rijen met postcode 20004, één met de plaats 'North Tower' en de andere met de stad 'Washington'.

   Bovendien toont de plot enkele schendingen en veel lege waarden.

2. Bevestig het aantal lege waarden voor Postal Code:

   customer_state_df['Postal Code'].isna().sum()
   

   50 rijen hebben NA voor postcode.

3. Verwijder rijen met lege waarden. Zoek vervolgens afhankelijkheden met behulp van de functie find_dependencies. Let op de extra parameter verbose=1 die een kijkje in de interne werking van SemPy biedt:

   customer_state_df2=customer_state_df.dropna()
   customer_state_df2.find_dependencies(verbose=1)
   

   De voorwaardelijke entropie voor Postal Code en City is 0,049. Deze waarde geeft aan dat er functionele afhankelijkheidsschendingen zijn. Voordat u de schendingen oplost, verhoogt u de drempelwaarde voor voorwaardelijke entropie van de standaardwaarde van 0.01 naar 0.05, alleen om de afhankelijkheden te zien. Lagere drempelwaarden resulteren in minder afhankelijkheden (of hogere selectiviteit).

4. Verhoog de drempelwaarde voor voorwaardelijke entropie van de standaardwaarde van 0.01 naar 0.05:

   plot_dependency_metadata(customer_state_df2.find_dependencies(threshold=0.05))
   

   

   Als u domeinkennis toepast van welke entiteit waarden van andere entiteiten bepaalt, lijkt deze afhankelijkhedengrafiek nauwkeurig.

5. Verken meer problemen met de kwaliteit van gegevens die zijn gedetecteerd. Een onderbroken pijl voegt bijvoorbeeld City en Regiontoe, wat aangeeft dat de afhankelijkheid alleen bij benadering is. Deze benaderingsrelatie kan betekenen dat er sprake is van een gedeeltelijke functionele afhankelijkheid.

   customer_state_df.list_dependency_violations('City', 'Region')
   

6. Bekijk elk van de gevallen waarin een lege Region waarde een schending veroorzaakt:

   customer_state_df[customer_state_df.City=='Downers Grove']
   

   Het resultaat toont de stad Downers Grove die voorkomt in Illinois en Nebraska. Downer's Grove is echter een stad in Illinois, niet Nebraska.

7. Kijk eens naar de stad Fremont:

   customer_state_df[customer_state_df.City=='Fremont']
   

   Er is een stad genaamd Fremont in Californië. Voor Texas retourneert de zoekmachine echter Premont, niet Fremont.

8. Het is ook verdacht om schendingen van de afhankelijkheid tussen Name en Country/Regionte zien, zoals opgegeven door de stippellijn in de oorspronkelijke grafiek met afhankelijkheidsschendingen (voordat de rijen met lege waarden worden verwijderd).

   customer_state_df.list_dependency_violations('Name', 'Country/Region')
   

   Het lijkt erop dat één klant, SDI Design aanwezig is in twee regio's: Verenigde Staten en Canada. Deze gebeurtenis is mogelijk geen semantische schending, maar kan gewoon een ongebruikelijk geval zijn. Toch is het de moeite waard om een kijkje te nemen:

9. Kijk eens goed naar de klant SDI Design:

   customer_state_df[customer_state_df.Name=='SDI Design']
   

   Verder onderzoek laat zien dat het eigenlijk twee verschillende klanten (uit verschillende branches) met dezelfde naam is.

Verkennende gegevensanalyse is een spannend proces en dat geldt ook voor het opschonen van gegevens. Er is altijd iets dat de gegevens verbergen, afhankelijk van hoe u deze bekijkt, wat u wilt vragen, enzovoort. Semantische koppeling biedt u nieuwe hulpprogramma's die u kunt gebruiken om meer te bereiken met uw gegevens.

Verwante inhoud

Bekijk andere handleidingen voor semantische koppeling /SemPy:

• Zelfstudie: Gegevens opschonen met functionele afhankelijkheden
• Zelfstudie: Power BI-metingen extraheren en berekenen uit een Jupyter-notebook
• Zelfstudie: Relaties ontdekken in een semantisch model met behulp van semantische koppeling
• Zelfstudie: Relaties ontdekken in de Synthea--gegevensset met behulp van semantische koppeling
• Zelfstudie: Gegevens valideren met behulp van SemPy en Great Expectations (GX)