Partilhar via

Tutorial: Validar dados usando SemPy e Grandes Expectativas (GX)

  • Artigo

Neste tutorial, você aprenderá a usar o SemPy junto com Grandes Expectativas (GX) para executar a validação de dados em modelos semânticos do Power BI.

Este tutorial mostrar-lhe como:

  • Valide restrições em um conjunto de dados em seu espaço de trabalho de malha com a fonte de dados de malha do Great Expectation (criada em link semântico).
    • Configure um contexto de dados GX, ativos de dados e expectativas.
    • Visualize os resultados da validação com um ponto de verificação GX.
  • Use o link semântico para analisar dados brutos.

Pré-requisitos

  • Obtenha uma assinatura do Microsoft Fabric. Ou inscreva-se para uma avaliação gratuita do Microsoft Fabric.

  • Entre no Microsoft Fabric.

  • Use o seletor de experiência no lado esquerdo da sua página inicial para alternar para a experiência Synapse Data Science.

    Captura de tela do menu do seletor de experiência, mostrando onde selecionar Ciência de Dados.

  • Selecione Espaços de trabalho no painel de navegação esquerdo para localizar e selecionar seu espaço de trabalho. Este espaço de trabalho torna-se o seu espaço de trabalho atual.
  • Baixe o arquivo PBIX.pbix de exemplo de análise de varejo.
  • Em seu espaço de trabalho, use o botão Carregar para carregar o arquivo PBIX.pbix de exemplo de análise de varejo no espaço de trabalho.

Acompanhe no caderno

great_expectations_tutorial.ipynb é o notebook que 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 seu espaço de trabalho.

Se preferir copiar e colar o código desta página, pode criar um novo bloco de notas.

Certifique-se de anexar um lakehouse ao bloco de anotações antes de começar a executar o código.

Configurar o bloco de notas

Nesta seção, você configura um ambiente de notebook com os módulos e dados necessários.

  1. Instale SemPy e as bibliotecas relevantes Great Expectations do PyPI usando o %pip recurso de instalação em linha dentro do notebook.
# install libraries
%pip install semantic-link great-expectations great_expectations_experimental great_expectations_zipcode_expectations

# load %%dax cell magic
%load_ext sempy
  1. Execute as importações necessárias de módulos que você precisará mais tarde:
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

Configurar o contexto de dados GX e a fonte de dados

Para começar com Grandes Expectativas, primeiro você precisa configurar um contexto de dados GX. O contexto serve como um ponto de entrada para operações GX e contém todas as configurações relevantes.

context = gx.get_context()

Agora você pode adicionar seu conjunto de dados de malha a esse contexto como uma fonte de dados para começar a interagir com os dados. Este tutorial usa um arquivo .pbix de exemplo padrão do modelo semântico de exemplo do Power BI Retail Analysis.

ds = context.sources.add_fabric_powerbi("Retail Analysis Data Source", dataset="Retail Analysis Sample PBIX")

Especificar ativos de dados

Defina Ativos de Dados para especificar o subconjunto de dados com o qual você gostaria de trabalhar. O ativo pode ser tão simples quanto tabelas completas ou ser tão complexo quanto uma consulta DAX (Data Analysis Expressions) personalizada.

Aqui, você adicionará vários ativos:

Tabela do Power BI

Adicione uma tabela do Power BI como um ativo de dados.

ds.add_powerbi_table_asset("Store Asset", table="Store")

Medida do Power BI

Se o conjunto de dados contiver medidas pré-configuradas evaluate_measure, você adicionará as medidas como ativos seguindo uma API semelhante à do SemPy.

ds.add_powerbi_measure_asset(
    "Total Units Asset",
    measure="TotalUnits",
    groupby_columns=["Time[FiscalYear]", "Time[FiscalMonth]"]
)

DAX

Se quiser definir suas próprias medidas ou ter mais controle sobre linhas específicas, você pode adicionar um ativo DAX com uma consulta DAX personalizada. Aqui, definimos uma Total Units Ratio medida dividindo duas medidas existentes.

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])
    )    
    """
)

Consulta Detran

Em alguns casos, pode ser útil usar cálculos de DMV (Dynamic Management View ) como parte do processo de validação de dados. Por exemplo, você pode acompanhar o número de violações de integridade referencial em seu conjunto de dados. Para obter mais informações, consulte Limpar dados = relatórios mais rápidos.

ds.add_powerbi_dax_asset(
    "Referential Integrity Violation",
    dax_string=
    """
    SELECT
        [Database_name],
        [Dimension_Name],
        [RIVIOLATION_COUNT]
    FROM $SYSTEM.DISCOVER_STORAGE_TABLES
    """
)

Expectativas

Para adicionar restrições específicas aos ativos, primeiro é necessário configurar o Expectation Suites. Depois de adicionar expectativas individuais a cada pacote, você pode atualizar o contexto de dados configurado no início com o novo pacote. Para obter uma lista completa das expectativas disponíveis, consulte a Galeria de expectativas GX.

Comece adicionando um "Retail Store Suite" com duas expectativas:

  • um código postal válido
  • uma tabela com contagem de linhas entre 80 e 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 Medida

Adicione um "Retail Measure Suite" com uma expectativa:

  • Os valores da coluna devem ser superiores a 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

Adicione um "Retail DAX Suite" com uma expectativa:

  • Os valores de coluna para o Rácio de Unidades Totais devem estar entre 0,8 e 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)

Violações de Integridade Referencial (Detran)

Adicione um "Retail DMV Suite" com uma expectativa:

  • o RIVIOLATION_COUNT deve ser 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)

Validação

Para realmente executar as expectativas especificadas em relação aos dados, primeiro crie um Ponto de verificação e adicione-o ao contexto. Para obter mais informações sobre a configuração do ponto de verificação, consulte Fluxo de trabalho de validação de dados.

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
)

Agora execute o ponto de verificação e extraia os resultados como um DataFrame pandas para formatação simples.

result = checkpoint.run()

Processe e imprima os seus resultados.

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"]]

A tabela mostra os resultados da validação.

A partir desses resultados, você pode ver que todas as suas expectativas passaram pela validação, exceto o "Total de Unidades YoY Asset" que você definiu por meio de uma consulta DAX personalizada.

Diagnóstico

Usando o link semântico, você pode buscar os dados de origem para entender quais anos exatos estão fora do intervalo. O link semântico fornece uma mágica embutida para executar consultas DAX. Use o link semântico para executar a mesma consulta que você passou para o GX Data Asset e visualizar os valores resultantes.

%%dax "Retail Analysis Sample PBIX"

EVALUATE SUMMARIZECOLUMNS(
    'Time'[FiscalYear],
    'Time'[FiscalMonth],
    "Total Units Ratio", DIVIDE([Total Units This Year], [Total Units Last Year])
)

A tabela mostra os resultados do resumo da consulta DAX.

Salve esses resultados em um DataFrame.

df = _

Plote os resultados.

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

O gráfico mostra os resultados do resumo da consulta DAX.

Pelo enredo, é possível ver que abril e julho estavam um pouco fora de alcance e podem então tomar outras medidas para investigar.

Armazenando a configuração GX

Como os dados em seu conjunto de dados mudam ao longo do tempo, convém executar novamente as validações GX que acabou de executar. Atualmente, o Contexto de Dados (que contém os Ativos de Dados conectados, os Pacotes de Expectativas e o Ponto de Verificação) vive de forma efêmica, mas pode ser convertido em um Contexto de Arquivo para uso futuro. Como alternativa, você pode instanciar um contexto de arquivo (consulte Instanciar um contexto de dados).

context = context.convert_to_file_context()

Agora que você salvou o contexto, copie o diretório para sua gx casa do lago.

Importante

Esta célula pressupõe que você adicionou uma casa de lago ao bloco de anotações. Se não houver nenhuma casa do lago anexada, você não verá um erro, mas também não poderá obter o contexto mais tarde. Se você adicionar um lakehouse agora, o kernel será reiniciado, então você terá que executar novamente todo o notebook para voltar a este ponto.

# copy GX directory to attached lakehouse
!cp -r gx/ /lakehouse/default/Files/gx

Agora, contextos futuros podem ser criados com context = gx.get_context(project_root_dir="<your path here>") para usar todas as configurações deste tutorial.

Por exemplo, em um novo bloco de anotações, anexe a mesma casa do lago e use context = gx.get_context(project_root_dir="/lakehouse/default/Files/gx") para recuperar o contexto.

Conteúdos relacionados

Confira outros tutoriais para link semântico / SemPy: