Tutorial Parte 2: Explorar e visualizar dados usando notebooks do Microsoft Fabric

Artigo
02/05/2025

Neste tutorial, você aprenderá a conduzir a análise exploratória de dados (EDA) para examinar e investigar os dados, resumindo suas principais características por meio do uso de técnicas de visualização de dados.

Você usará seaborn, uma biblioteca de visualização de dados do Python que fornece uma interface de alto nível para criar visuais em dataframes e matrizes. Para obter mais informações sobre seaborn, consulte Seaborn: Visualização de Dados Estatísticos.

Você também usará Data Wrangler, uma ferramenta baseada em notebook que fornece uma experiência imersiva para realizar a análise e a limpeza de dados exploratórios.

As principais etapas neste tutorial são:

Ler os dados armazenados de uma tabela delta no lakehouse.
Converta um DataFrame do Spark para um DataFrame do Pandas, que as bibliotecas de visualização do Python suportam.
Use o Data Wrangler para executar a limpeza e a transformação de dados iniciais.
Executar análise de dados exploratória usando seaborn.

Pré-requisitos

Obtenha uma assinatura do Microsoft Fabric. Ou cadastre-se para uma avaliação gratuita do Microsoft Fabric.
Entre no Microsoft Fabric.
Use o alternador de experiência no canto inferior esquerdo da sua página inicial para alternar para o Fabric.

Essa é a parte 2 de 5 da série de tutoriais. Para concluir este tutorial, primeiro conclua:

Parte 1: Ingerir dados em um Microsoft Fabric Lakehouse usando Apache Spark.

Acompanhar no notebook

2-explore-cleanse-data.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 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.

Importante

Anexe a mesma casa de lago que você usou na Parte 1.

Ler dados brutos do lakehouse

Leia dados brutos da seção Arquivos da lakehouse. Você carregou esses dados no notebook anterior. Certifique-se de ter anexado o mesmo lakehouse usado na Parte 1 a este notebook antes de executar esse código.

df = (
    spark.read.option("header", True)
    .option("inferSchema", True)
    .csv("Files/churn/raw/churn.csv")
    .cache()
)

Criar um DataFrame pandas com base no conjunto de dados

Converta o DataFrame do Spark em DataFrame do Pandas para facilitar o processamento e a visualização.

df = df.toPandas()

Exibir dados brutos

Explore os dados brutos com display, faça cálculos básicos de estatísticas e mostre gráficos. Observe que primeiro você precisa importar as bibliotecas necessárias, como Numpy, Pnadas, Seaborne Matplotlib para análise e visualização de dados.

import seaborn as sns
sns.set_theme(style="whitegrid", palette="tab10", rc = {'figure.figsize':(9,6)})
import matplotlib.pyplot as plt
import matplotlib.ticker as mticker
from matplotlib import rc, rcParams
import numpy as np
import pandas as pd
import itertools

display(df, summary=True)

Usar o Data Wrangler para executar a limpeza inicial de dados

Para explorar e transformar quaisquer Dataframes pandas em seu notebook, inicie o Estruturador de Dados diretamente do notebook.

Nota

O Wrangler de Dados não pode ser aberto enquanto o kernel do notebook está ocupado. A execução da célula deve ser concluída antes de iniciar o Data Wrangler.

Na guia Dados da faixa de opções do notebook, selecione Iniciar Estruturador de Dados. Você verá uma lista de DataFrames do Pandas ativados disponíveis para edição.
Selecione o DataFrame que você deseja abrir no Data Wrangler. Como este notebook contém apenas um DataFrame, df, selecione df.

A captura de tela mostra como iniciar o organizador de dados a partir de um notebook.

O Data Wrangler inicia e gera uma visão geral descritiva dos dados. A tabela no meio mostra cada coluna de dados. O painel Resumo ao lado da tabela mostra informações sobre o DataFrame. Quando você seleciona uma coluna na tabela, o resumo é atualizado com informações sobre a coluna selecionada. Em alguns casos, os dados exibidos e resumidos serão uma exibição truncada do DataFrame. Quando isso acontecer, você verá a imagem de aviso no painel de resumo. Passe o mouse sobre esse aviso para exibir o texto explicando a situação.

Cada operação que você fizer pode ser aplicada em uma questão de cliques, atualizando a exibição de dados em tempo real e gerando código que você pode salvar de volta em seu notebook como uma função reutilizável.

O restante desta seção orienta você pelas etapas para executar a limpeza de dados com o Data Wrangler.

Remover linhas duplicadas

No painel esquerdo há uma lista de operações (como Localizar e substituir, Format, Formulas, Numeric) que você pode executar no conjunto de dados.

Expanda Localizar e substituir e selecione Descartar linhas duplicadas.
Um painel é exibido para você selecionar a lista de colunas que deseja comparar para definir uma linha duplicada. Selecione RowNumber e CustomerId.

No painel do meio há uma visualização dos resultados dessa operação. Na visualização está o código para executar a operação. Nesse caso, os dados parecem estar inalterados. Mas como você está olhando para uma exibição truncada, é uma boa ideia ainda aplicar a operação.
Selecione Aplicar (na lateral ou na parte inferior) para ir para a próxima etapa.

Remover linhas com dados ausentes

Use o Data Wrangler para remover linhas com dados ausentes em todas as colunas.

Selecione Remover valores ausentes de Localizar e substituir.
Escolha Selecionar tudo nas Colunas de destino.
Selecione Aplicar para ir para a próxima etapa.

Remover colunas

Use o Data Wrangler para remover colunas que você não precisa.

Expanda Esquema e selecione Descartar colunas.
Selecione RowNumber, CustomerId, Sobrenome. Essas colunas aparecem em vermelho na versão prévia, para mostrar que são alteradas pelo código (nesse caso, descartadas).)
Selecione Aplicar para ir para a próxima etapa.

Adicionar código ao notebook

Cada vez que você seleciona Aplicar, uma nova etapa é criada no painel Etapas de limpeza na parte inferior esquerda. Na parte inferior do painel, selecione Código de visualização para todas as etapas para exibir uma combinação de todas as etapas separadas.

Selecione Adicionar código ao bloco de anotações na parte superior esquerda para fechar o Data Wrangler e adicionar o código automaticamente. Adicionar código ao notebook encapsula o código em uma função e, em seguida, chama a função.

Captura de tela mostra o código de pré-visualização e onde acessar para adicionar ao notebook.

Dica

O código gerado pelo Data Wrangler não será aplicado até que você execute manualmente a nova célula.

Se você não usou o Data Wrangler, poderá usar essa próxima célula de código.

Esse código é semelhante ao código produzido pelo Data Wrangler, mas adiciona o argumento inplace=True a cada uma das etapas geradas. Ao definir inplace=True, Pandas substituirá o DataFrame original em vez de produzir um novo DataFrame como resultado.

# Modified version of code generated by Data Wrangler 
# Modification is to add in-place=True to each step

# Define a new function that include all above Data Wrangler operations
def clean_data(df):
    # Drop rows with missing data across all columns
    df.dropna(inplace=True)
    # Drop duplicate rows in columns: 'RowNumber', 'CustomerId'
    df.drop_duplicates(subset=['RowNumber', 'CustomerId'], inplace=True)
    # Drop columns: 'RowNumber', 'CustomerId', 'Surname'
    df.drop(columns=['RowNumber', 'CustomerId', 'Surname'], inplace=True)
    return df

df_clean = clean_data(df.copy())
df_clean.head()

Explorar os dados

Exiba alguns resumos e visualizações dos dados limpos.

Determinar atributos categóricos, numéricos e de destino

Use esse código para determinar atributos categóricos, numéricos e de destino.

# Determine the dependent (target) attribute
dependent_variable_name = "Exited"
print(dependent_variable_name)
# Determine the categorical attributes
categorical_variables = [col for col in df_clean.columns if col in "O"
                        or df_clean[col].nunique() <=5
                        and col not in "Exited"]
print(categorical_variables)
# Determine the numerical attributes
numeric_variables = [col for col in df_clean.columns if df_clean[col].dtype != "object"
                        and df_clean[col].nunique() >5]
print(numeric_variables)

O resumo de cinco números

Mostrar o resumo de cinco números (a pontuação mínima, primeiro quartil, mediana, terceiro quartil, a pontuação máxima) para os atributos numéricos, usando gráficos de caixa.

df_num_cols = df_clean[numeric_variables]
sns.set(font_scale = 0.7) 
fig, axes = plt.subplots(nrows = 2, ncols = 3, gridspec_kw =  dict(hspace=0.3), figsize = (17,8))
fig.tight_layout()
for ax,col in zip(axes.flatten(), df_num_cols.columns):
    sns.boxplot(x = df_num_cols[col], color='green', ax = ax)
fig.delaxes(axes[1,2])

O gráfico mostra os resumos de cinco números.

Distribuição de clientes encerrados e inexistentes

Mostrar a distribuição de clientes encerrados versus não anexados entre os atributos categóricos.

attr_list = ['Geography', 'Gender', 'HasCrCard', 'IsActiveMember', 'NumOfProducts', 'Tenure']
fig, axarr = plt.subplots(2, 3, figsize=(15, 4))
for ind, item in enumerate (attr_list):
    sns.countplot(x = item, hue = 'Exited', data = df_clean, ax = axarr[ind%2][ind//2])
fig.subplots_adjust(hspace=0.7)

Distribuição de atributos numéricos

Mostrar a distribuição de frequência de atributos numéricos usando histograma.

columns = df_num_cols.columns[: len(df_num_cols.columns)]
fig = plt.figure()
fig.set_size_inches(18, 8)
length = len(columns)
for i,j in itertools.zip_longest(columns, range(length)):
    plt.subplot((length // 2), 3, j+1)
    plt.subplots_adjust(wspace = 0.2, hspace = 0.5)
    df_num_cols[i].hist(bins = 20, edgecolor = 'black')
    plt.title(i)
plt.show()

Executar engenharia de recursos

Execute a engenharia de recursos para gerar novos atributos com base nos atributos atuais:

df_clean["NewTenure"] = df_clean["Tenure"]/df_clean["Age"]
df_clean["NewCreditsScore"] = pd.qcut(df_clean['CreditScore'], 6, labels = [1, 2, 3, 4, 5, 6])
df_clean["NewAgeScore"] = pd.qcut(df_clean['Age'], 8, labels = [1, 2, 3, 4, 5, 6, 7, 8])
df_clean["NewBalanceScore"] = pd.qcut(df_clean['Balance'].rank(method="first"), 5, labels = [1, 2, 3, 4, 5])
df_clean["NewEstSalaryScore"] = pd.qcut(df_clean['EstimatedSalary'], 10, labels = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

Use o Data Wrangler para executar a codificação one-hot

O Estruturador de Dados também pode ser usado para executar codificação one-hot. Para fazer isso, abra novamente o Data Wrangler. Desta vez, selecione os dados df_clean.

Expanda Fórmulas e selecione Codificação one-hot.
Um painel é exibido para você selecionar a lista de colunas em que deseja executar a codificação one-hot. Selecione Geografia e Gênero.

Você pode copiar o código gerado, fechar o Data Wrangler para retornar ao notebook e colar em uma nova célula. Ou selecione Adicionar código ao notebook na parte superior esquerda para fechar o Estruturador de Dados e adicionar o código automaticamente.

Se você não tiver usado o Data Wrangler, poderá usar esta próxima célula de código:

# This is the same code that Data Wrangler will generate
 
import pandas as pd
 
def clean_data(df_clean):
    # One-hot encode columns: 'Geography', 'Gender'
    df_clean = pd.get_dummies(df_clean, columns=['Geography', 'Gender'])
    return df_clean
 
df_clean_1 = clean_data(df_clean.copy())
df_clean_1.head()

Resumo das observações da análise de dados exploratórios

A maioria dos clientes é da França em comparação com a Espanha e a Alemanha, enquanto a Espanha tem a menor taxa de variação em comparação com a França e a Alemanha.
A maioria dos clientes tem cartões de crédito.
Há clientes cuja idade e pontuação de crédito estão acima de 60 e abaixo de 400, respectivamente, mas eles não podem ser considerados como exceções.
Muito poucos clientes têm mais de dois produtos do banco.
Os clientes que não estão ativos têm uma taxa de variação mais alta.
Gênero e anos de atuação não parecem ter impacto na decisão do cliente de encerrar a conta bancária.

Criar uma tabela delta para os dados limpos

Você usará esses dados no próximo bloco de anotações desta série.

table_name = "df_clean"
# Create Spark DataFrame from pandas
sparkDF=spark.createDataFrame(df_clean_1) 
sparkDF.write.mode("overwrite").format("delta").save(f"Tables/{table_name}")
print(f"Spark dataframe saved to delta table: {table_name}")

Próxima etapa

Treine e registre modelos de machine learning com esses dados:

Parte 3: Treinar e registrar modelos de machine learning.

Compartilhar via