Tutorial: Analisar dependências funcionais em um modelo semântico

Neste tutorial, você se baseia no trabalho de um analista do Power BI armazenado como modelos semânticos (conjuntos de dados do Power BI). Usando o SemPy (versão prévia) na experiência de Ciência de Dados do Synapse no Microsoft Fabric, você analisa dependências funcionais em colunas do DataFrame. Essa análise ajuda você a descobrir problemas sutis de qualidade de dados para obter insights mais precisos.

Neste tutorial, você aprenderá a:

Aplique conhecimento de domínio para formular hipóteses sobre dependências funcionais em um modelo semântico.
Familiarize-se com componentes da SemPy (biblioteca Python) do Semmantic Link que se integram ao Power BI e ajudam a automatizar a análise de qualidade dos dados. Esses componentes incluem:
- FabricDataFrame — estrutura semelhante a pandas aprimorada com informações semânticas adicionais
- Funções que puxam modelos semânticos de um workspace do Fabric para seu notebook
- Funções que avaliam hipóteses de dependência funcional e identificam violações de relação em seus modelos semânticos

Pré-requisitos

Obtenha uma assinatura do Microsoft Fabric. Ou inscreva-se para experimentar gratuitamente o Microsoft Fabric .
Entre no Microsoft Fabric.
Alterne para o Fabric usando o alternador de experiências no canto inferior esquerdo da página inicial.

Selecione Workspaces no painel de navegação para localizar e selecionar seu workspace. Esse espaço de trabalho se torna o seu espaço de trabalho atual.
Baixe o arquivo Customer Profitability Sample.pbix do repositório GitHub de exemplos de malha.
Em seu workspace, selecione Importar>Relatório ou Relatório Paginado>Deste computador para carregar o arquivo Customer Profitability Sample.pbix para seu workspace.

Acompanhar no notebook

O notebook powerbi_dependencies_tutorial.ipynb acompanha este tutorial.

Para abrir o bloco de anotações que acompanha este tutorial, siga as instruções em Preparar seu sistema para tutoriais de ciência de dados para importar o bloco de anotações para sua área de trabalho.
Se você prefere copiar e colar o código desta página, pode criar um notebook.
Certifique-se de anexar um lakehouse ao notebook antes de começar a executar o código.

Configurar o notebook

Configure um ambiente de notebook com os módulos e os dados necessários.

Use %pip para instalar o SemPy do PyPI no notebook.
```
%pip install semantic-link
```

Importe os módulos necessários.

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

Carregar e pré-processar os dados

Este tutorial usa um modelo semântico de exemplo padrão Customer Profitability Sample.pbix. Para obter uma descrição do modelo semântico, consulte exemplo de Rentabilidade do Cliente para o Power BI.

Carregue dados do Power BI em um FabricDataFrame usando a fabric.read_table função.

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

Carregue a State tabela em um FabricDataFrame.
```
state = fabric.read_table(dataset, "State")
state.head()
```
Embora a saída pareça um DataFrame pandas, esse código inicializa uma estrutura de dados chamada a FabricDataFrame que adiciona operações sobre pandas.
Verifique o tipo de dados de customer.
```
type(customer)
```
A saída mostra que customer é sempy.fabric._dataframe._fabric_dataframe.FabricDataFrame.

Junte-se ao customer objeto e stateDataFrame ao objeto.

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

Identificar dependências funcionais

Uma dependência funcional é uma relação um-para-muitos entre valores em duas ou mais colunas em um DataFrame. Use essas relações para detectar automaticamente problemas de qualidade de dados.

Execute a função semPy find_dependencies na mesclada DataFrame para identificar dependências funcionais entre valores de coluna.
```
dependencies = customer_state_df.find_dependencies()
dependencies
```
Visualize as dependências usando a função do plot_dependency_metadata SemPy.
```
plot_dependency_metadata(dependencies)
```
O grafo de dependências funcionais mostra que a Customer coluna determina colunas como City, Postal Codee Name.

O grafo não mostra uma dependência funcional entre City e Postal Code, provavelmente, porque há muitas violações na relação entre as colunas. Use a função do plot_dependency_violations SemPy para visualizar violações de dependência entre colunas específicas.

Verificar os dados para questões de qualidade

Desenhe um grafo com a função de visualização plot_dependency_violations do SemPy.
```
customer_state_df.plot_dependency_violations('Postal Code', 'City')
```
O gráfico de violações de dependência mostra valores para Postal Code o lado esquerdo e valores para City o lado direito. Uma borda conecta um Postal Code no lado esquerdo com um City no lado direito se houver uma linha que contenha esses dois valores. As bordas são anotadas com a contagem dessas linhas. Por exemplo, há duas linhas com o código postal 20004, uma com a cidade "North Tower" e outra com a cidade "Washington".

O gráfico também mostra algumas violações e muitos valores vazios.
Confirme o número de valores vazios para Postal Code:
```
customer_state_df['Postal Code'].isna().sum()
```
50 linhas têm NA para Postal Code.
Remova linhas com valores vazios. Em seguida, localize dependências usando a função find_dependencies. Observe o parâmetro extra verbose=1 que oferece um vislumbre do funcionamento interno do SemPy:
```
customer_state_df2=customer_state_df.dropna()
customer_state_df2.find_dependencies(verbose=1)
```
A entropia condicional para Postal Code e City é 0,049. Esse valor indica que há violações de dependência funcional. Antes de corrigir as violações, aumente o limite de entropia condicional do valor padrão de 0.01 para 0.05, apenas para ver as dependências. Limites inferiores resultam em menos dependências (ou maior seletividade).
Aumente o limite na entropia condicional do valor padrão de 0.01 para 0.05:
```
plot_dependency_metadata(customer_state_df2.find_dependencies(threshold=0.05))
```
Se você aplicar o conhecimento de domínio de qual entidade determina os valores de outras entidades, esse grafo de dependência parece preciso.
Explore mais problemas de qualidade de dados detectados. Por exemplo, uma seta tracejada une City e Region, o que indica que a dependência é apenas aproximada. Essa relação aproximada pode implicar que há uma dependência funcional parcial.
```
customer_state_df.list_dependency_violations('City', 'Region')
```
Dê uma olhada mais de perto em cada um dos casos em que um valor de Region não inteiro causa uma violação:
```
customer_state_df[customer_state_df.City=='Downers Grove']
```
O resultado mostra a cidade de Downers Grove em Illinois e Nebraska. No entanto, Downers Grove é uma cidade em Illinois, não Nebraska.
Dê uma olhada na cidade de Fremont:
```
customer_state_df[customer_state_df.City=='Fremont']
```
Há uma cidade chamada Fremont na Califórnia. No entanto, para o Texas, o mecanismo de pesquisa retorna Premont, não Fremont.
Também é suspeito ver violações da dependência entre Name e Country/Region, conforme indicado pela linha pontilhada no grafo original de violações de dependência (antes de remover as linhas com valores vazios).
```
customer_state_df.list_dependency_violations('Name', 'Country/Region')
```
Um cliente, o SDI Design, aparece em duas regiões: Estados Unidos e Canadá. Este caso pode não ser uma violação semântica, apenas incomum. Ainda assim, vale a pena dar uma olhada de perto:
Examine mais de perto no Design de SDI do cliente:
```
customer_state_df[customer_state_df.Name=='SDI Design']
```
Uma inspeção adicional mostra dois clientes diferentes de setores diferentes com o mesmo nome.

A análise de dados exploratória e a limpeza de dados são iterativas. O que você encontra depende de suas perguntas e perspectivas. O Link Semântico oferece novas ferramentas para obter mais de seus dados.

Confira outros tutoriais para link semântico e SemPy:

Comentários

Esta página foi útil?

Last updated on 2025-08-28