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

Artigo
12/22/2023

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á o Estruturador de Dados, 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 na lakehouse.
Converter um DataFrame do Spark em DataFrame do Pandas, com suporte para bibliotecas de visualização do Python.
Usar o Estruturador de Dados para executar a limpeza e a transformação de dados iniciais.
Executar a análise de dados exploratória usando seaborn.

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 alternador de experiência no lado esquerdo da sua página inicial para mudar para a experiência de Ciência de Dados Synapse.

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

Parte 1: Ingerir dados em um lakehouse do Microsoft Fabric usando o Apache Spark.

Acompanhar no notebook

2-explore-cleanse-data.ipynb é o notebook que acompanha este tutorial.

Para abrir o notebook que acompanha este tutorial, siga as instruções em Preparar seu sistema para tutoriais de ciência de dados para importar os notebooks para seu workspace.

Se preferir copiar e colar o código a partir dessa página, você poderá criar um novo 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 do 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 algumas estatísticas básicas e mostre exibições de gráficos. Observe que primeiro você precisa importar as bibliotecas necessárias, como Numpy, Pnadas, Seaborn e 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 Estruturador de Dados 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.

Observação

O Data Wrangler não pode ser aberto enquanto o kernel do notebook estiver 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 Estruturador de Dados. Como este notebook contém apenas um DataFrame, df, selecione df.

A captura de tela mostra como iniciar o data wrangler a partir de um bloco de anotações.

O Estruturador de Dados 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 Estruturador de Dados.

Soltar linhas duplicadas

No painel esquerdo há uma lista de operações (como Localizar e substituir, Formatar, Fórmulas, Numérico) 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 Estruturador de Dados 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 Estruturador de Dados 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 Visualizar código para todas as etapas para exibir uma combinação de todas as etapas separadas.

Selecione Adicionar código ao notebook 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.

A captura de tela mostra o código de visualização e onde acessar e adicionar ao bloco de anotações.

Dica

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

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

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

# 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 os atributos categorizados, 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 da frequência de atributos numéricos utilizando o 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 a 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 Estruturador de Dados. 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 Estruturador de Dados 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 Estruturador de Dados, 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 exploratória de dados

A maioria dos clientes é da França em comparação com a Espanha e a Alemanha, enquanto a Espanha tem a menor taxa de rotatividade em comparação com a França e a Alemanha.
A maioria dos clientes tem cartão de crédito.
Existem clientes com idade e pontuação de crédito acima de 60 anos e abaixo de 400, respectivamente, mas que não podem ser considerados anômalos.
Pouquíssimos clientes têm mais de dois produtos do banco.
Os clientes que não estão ativos têm uma taxa de rotatividade mais alta.
O gênero e os anos de posse não parecem ter um impacto sobre a 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 notebook 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