Zelfstudie: Functionele afhankelijkheden in een semantisch model analyseren

In deze zelfstudie bouwt u voort op werk door een Power BI-analist die is opgeslagen als semantische modellen (Power BI-gegevenssets). Door SemPy (preview) te gebruiken in de Synapse Data Science-ervaring in Microsoft Fabric, analyseert u functionele afhankelijkheden in DataFrame-kolommen. Met deze analyse kunt u subtiele problemen met gegevenskwaliteit ontdekken om nauwkeurigere inzichten te krijgen.

In deze zelfstudie leert u het volgende:

Pas domeinkennis toe om hypothesen te formuleren over functionele afhankelijkheden in een semantisch model.
Maak kennis met onderdelen van de Python-bibliotheek (SemPy) van Semantic Link die zijn geïntegreerd met Power BI en help bij het automatiseren van gegevenskwaliteitsanalyse. Deze onderdelen zijn onder andere:
- FabricDataFrame: pandas-achtige structuur verbeterd met aanvullende semantische informatie
- Functies die semantische modellen uit een Fabric-werkruimte naar uw notebook halen
- Functies die functionele afhankelijkheidshypotheses evalueren en relatieschendingen in uw semantische modellen identificeren

Voorwaarden

Een Microsoft Fabric-abonnementophalen. Of meld u aan voor een gratis microsoft Fabric-proefversie.
Meld u aan bij Microsoft Fabric-.
Schakel over naar Fabric met behulp van de ervaringsschakelaar aan de linkerkant van de startpagina.

Selecteer Werkruimten in het navigatiedeelvenster om uw werkruimte te zoeken en te selecteren. Deze werkruimte wordt uw huidige werkruimte.
Download het bestand Customer Profitability Sample.pbix 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 u een lakehouse aan het notebook koppelt voordat u begint met het uitvoeren van code.

Het notebook instellen

Stel een notebookomgeving in met de modules en gegevens die u nodig hebt.

Gebruik %pip dit om SemPy te installeren vanuit PyPI in het notebook.
```
%pip install semantic-link
```

Importeer de modules die u 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.

Power BI-gegevens laden in een FabricDataFrame met behulp van de fabric.read_table functie.

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

Laad de State tabel in een FabricDataFrame.
```
state = fabric.read_table(dataset, "State")
state.head()
```
Hoewel de uitvoer eruitziet als een Pandas DataFrame, initialiseert deze code een gegevensstructuur die een FabricDataFrame gegevensstructuur wordt genoemd die bewerkingen toevoegt boven op pandas.
Controleer het gegevenstype van customer.
```
type(customer)
```
In de uitvoer ziet u dat customer dit is sempy.fabric._dataframe._fabric_dataframe.FabricDataFrame.

Voeg de customer en stateDataFrame objecten toe.

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

Functionele afhankelijkheden identificeren

Een functionele afhankelijkheid is een een-op-veel-relatie tussen waarden in twee of meer kolommen in een DataFrame. Gebruik deze relaties om problemen met gegevenskwaliteit automatisch te detecteren.

Voer de functie van find_dependencies SemPy uit op de samengevoegde DataFrame functie om functionele afhankelijkheden tussen kolomwaarden te identificeren.
```
dependencies = customer_state_df.find_dependencies()
dependencies
```
Visualiseer de afhankelijkheden met behulp van de functie van plot_dependency_metadata SemPy.
```
plot_dependency_metadata(dependencies)
```
In de grafiek met functionele afhankelijkheden ziet u dat de Customer kolom kolommen zoals City, Postal Codeen Name.

In de grafiek wordt geen functionele afhankelijkheid weergegeven tussen City en Postal Code, waarschijnlijk omdat er veel schendingen zijn in de relatie tussen de kolommen. Gebruik de functie van plot_dependency_violations SemPy om afhankelijkheidsschendingen tussen specifieke kolommen te visualiseren.

De gegevens voor kwaliteitsproblemen verkennen

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 worden waarden weergegeven 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'.

In de plot worden ook enkele schendingen en veel lege waarden weergegeven.
Bevestig het aantal lege waarden voor Postal Code:
```
customer_state_df['Postal Code'].isna().sum()
```
50 rijen hebben N.V. voor Postal Code.
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).
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 de waarden van andere entiteiten bepaalt, lijkt deze afhankelijkheidsgrafiek nauwkeurig.
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')
```
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 in Illinois en Nebraska. Downers Grove is echter een stad in Illinois, niet Nebraska.
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.
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')
```
Eén klant, SDI Design, wordt weergegeven in twee regio's: Verenigde Staten en Canada. Dit geval is mogelijk geen semantische schending, gewoon ongebruikelijk. Toch is het de moeite waard om het volgende te bekijken:
Kijk eens goed naar de klant SDI Design:
```
customer_state_df[customer_state_df.Name=='SDI Design']
```
Bij verdere inspectie worden twee verschillende klanten uit verschillende branches met dezelfde naam weergegeven.

Verkennende gegevensanalyse en gegevens opschonen zijn iteratief. Wat u vindt, is afhankelijk van uw vragen en perspectief. Semantic Link biedt u nieuwe hulpprogramma's om meer uit uw gegevens te halen.

Bekijk andere zelfstudies voor semantische koppeling en SemPy:

Feedback

Is deze pagina nuttig?

Last updated on 2025-08-28