Identifiera relationer i en semantisk modell med hjälp av semantisk länk

Den här självstudien visar hur du använder en Jupyter-anteckningsbok för att interagera med Power BI och identifiera relationer mellan tabeller med SemPy-biblioteket.

I den här handledningen lär du dig att:

• Identifiera relationer i en semantisk modell (Power BI-datauppsättning) med hjälp av semantisk länks Python-bibliotek (SemPy).
• Använd SemPy-komponenter som integreras med Power BI och automatisera datakvalitetsanalys. Dessa komponenter omfattar:
  • FabricDataFrame - en Pandas-liknande struktur utökad med semantisk information
  • Funktioner som hämtar semantiska modeller från en Infrastruktur-arbetsyta till din notebook-fil
  • Funktioner som testar funktionella beroenden och identifierar relationsöverträdelser i dina semantiska modeller

Förutsättningar

• Skaffa en Microsoft Fabric-prenumeration. Eller registrera dig för en kostnadsfri Microsoft Fabric-utvärderingsversion.

• Logga in på Microsoft Fabric.

• Använd upplevelseväxlaren längst ner till vänster på din startsida för att byta till Fabric.

  

• Gå till Arbetsytor i navigeringsfönstret och välj sedan din arbetsyta för att ange den som den aktuella arbetsytan.

• Ladda ned exempel på kundlönsamhet Sample.pbix och Customer Profitability (auto).pbix semantiska modeller från GitHub-lagringsplatsen med infrastrukturexempel och ladda sedan upp dem till din arbetsyta.

Följ med i anteckningsboken

Följ med i notebook-filen powerbi_relationships_tutorial.ipynb .

• Om du vill öppna den medföljande notebook-filen för den här självstudien, följer du anvisningarna i Förberedelse av systemet för självstudier i datavetenskap för att importera anteckningsboken till din arbetsyta.

• Om du hellre kopierar och klistrar in koden från den här sidan kan du skapa en ny notebook-fil.

• Se till att bifoga ett lakehouse till notebook- innan du börjar köra kod.

Konfigurera anteckningsboken

Konfigurera en notebook-miljö med de moduler och data du behöver.

1. semantic-link Installera paketet från PyPI med hjälp av det %pip infogade kommandot i notebook-filen.

   %pip install semantic-link
   

2. Importera modulerna sempy som du ska använda senare.

   import sempy.fabric as fabric
   
   from sempy.relationships import plot_relationship_metadata
   from sempy.relationships import find_relationships
   from sempy.fabric import list_relationship_violations
   

3. pandas Importera biblioteket och ange ett visningsalternativ för utdataformatering.

   import pandas as pd
   pd.set_option('display.max_colwidth', None)
   

## Explore semantic models

This tutorial uses the Customer Profitability Sample semantic model [_Customer Profitability Sample.pbix_](https://github.com/microsoft/fabric-samples/blob/main/docs-samples/data-science/datasets/Customer%20Profitability%20Sample.pbix). Learn about the semantic model in [Customer Profitability sample for Power BI](/power-bi/create-reports/sample-customer-profitability).

- Use SemPy's `list_datasets` function to explore semantic models in your current workspace:

  ```python
  fabric.list_datasets()

För resten av den här notebook-filen använder du två versioner av semantikmodellen Customer Profitability Sample:

• Exempel på kundlönsamhet: den semantiska modellen som anges i Power BI-exemplen, med fördefinierade tabellrelationer
• Exempel på kundlönsamhet (automatiskt): samma data, men relationer är begränsade till dem som Power BI identifierar automatiskt

Extrahera fördefinierade relationer från exempelsemantikmodellen

1. Läs in de fördefinierade relationerna i semantikmodellen Exempel på kundlönsamhet med hjälp av SemPys list_relationships funktion. Funktionen visar relationer från tabellobjektmodellen (TOM).

   dataset = "Customer Profitability Sample"
   relationships = fabric.list_relationships(dataset)
   relationships
   

2. Visualisera relationships DataFrame som en graf med hjälp av SemPys plot_relationship_metadata funktion.

   plot_relationship_metadata(relationships)
   

   

   Det här diagrammet visar relationerna mellan tabeller i den här semantiska modellen enligt definitionen i Power BI av en ämnesexpert.

Identifiera ytterligare relationer

Om du börjar med relationer som Power BI identifierar automatiskt har du en mindre uppsättning.

1. Visualisera de relationer som Power BI automatiskt har definierat i den semantiska modellen:

   dataset = "Customer Profitability Sample (auto)"
   autodetected = fabric.list_relationships(dataset)
   plot_relationship_metadata(autodetected)
   

   

   Power BI:s autodetection missar många relationer. Dessutom är två av de automatiskt identifierade relationerna semantiskt felaktiga:

   • Executive[ID] ->Industry[ID]
   • BU[Executive_id] ->Industry[ID]

2. Skriv ut relationerna som en tabell:

   autodetected
   

   Raderna 3 och 4 visar felaktiga relationer till Industry tabellen. Ta bort dessa rader.

3. Ignorera de felaktigt identifierade relationerna.

   # Remove rows 3 and 4 which point incorrectly to Industry[ID]
   autodetected = autodetected[~autodetected.index.isin([3, 4])]
   

   Nu har du rätt men ofullständiga relationer. Visualisera dessa ofullständiga relationer med hjälp av plot_relationship_metadata:

   plot_relationship_metadata(autodetected)
   

   

4. Läs in alla tabeller från den semantiska modellen med hjälp av SemPys list_tables och funktioner och read_table leta sedan upp relationer mellan tabeller med hjälp av find_relationships. Granska loggutdata för att få insikter om hur den här funktionen fungerar:

   suggested_relationships_all = find_relationships(
       tables,
       name_similarity_threshold=0.7,
       coverage_threshold=0.7,
       verbose=2
   )
   

5. Visualisera nyligen identifierade relationer:

   plot_relationship_metadata(suggested_relationships_all)
   

   

   SemPy identifierar alla relationer.

6. Använd parametern exclude för att begränsa sökningen till ytterligare relationer som inte identifierades tidigare:

   additional_relationships = find_relationships(
       tables,
       exclude=autodetected,
       name_similarity_threshold=0.7,
       coverage_threshold=0.7
   )
   
   additional_relationships
   

Verifiera relationer

1. Läs först in data från semantikmodellen Exempel på kundlönsamhet .

   dataset = "Customer Profitability Sample"
   tables = {table: fabric.read_table(dataset, table) for table in fabric.list_tables(dataset)['Name']}
   
   tables.keys()
   

2. Kontrollera att primärnyckeln och sekundärnyckeln list_relationship_violations överlappar funktionen. Skicka utdata för list_relationships funktionen till list_relationship_violations.

   list_relationship_violations(tables, fabric.list_relationships(dataset))
   

   Resultaten visar användbara insikter. Ett av sju värden i Fact[Product Key] finns till exempel inte i Product[Product Key]och nyckeln som saknas är 50.

   Undersökande dataanalys och datarensning är iterativa. Vad du lär dig beror på dina frågor och hur du utforskar data. Semantisk länk lägger till verktyg som hjälper dig att göra mer med dina data.

Relaterat innehåll

Utforska andra självstudier för semantisk länk och 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 Notebook-
• Självstudie: Identifiera relationer i Synthea-datauppsättningen med hjälp av semantisk länk
• Självstudie: Verifiera data med SemPy och Great Expectations (GX)

\n\n