Polars: limpando e tratando dados

Encontrando dados faltantes - Apresentação

Introdução ao Curso de Limpeza e Tratamento de Dados

Olá! Você já precisou realizar limpeza e tratamento em uma grande quantidade de dados, mas não sabe qual é a forma mais eficiente de realizar esse processo? Neste curso, nós vamos construir um projeto prático de limpeza e tratamento de dados utilizando a biblioteca Polar's, que é muito eficiente em trabalhar com um grande volume de dados.

Projeto Prático com Base de Dados de Churn

Nós vamos utilizar uma base de dados de Churn, que será empregada em um modelo de Machine Learning para prever se um cliente deixará ou não de assinar o serviço. Nosso foco será nas tarefas de limpeza e tratamento dos dados, identificando as tarefas mais relevantes para preparar essa base de dados para uso no modelo de Machine Learning. No entanto, não abordaremos a etapa de treinamento do modelo de Machine Learning.

Tarefas de Limpeza e Tratamento de Dados

Ao longo do curso, vamos explorar tarefas como limpeza de dados nulos, tratamento de outliers e transformação de variáveis em nossa base de dados. Ao final do curso, teremos esse projeto construído, conforme está sendo mostrado na tela.

Detalhamento das Tarefas do Projeto

Ao longo do projeto, nós realizaremos tarefas como encontrar dados faltantes, dados nulos, tratar valores numéricos da base de dados, tratar variáveis categóricas que podem estar em formato de texto, tratar outliers da base de dados e também transformar variáveis para o formato binário. Ao longo do curso, nós executaremos todas essas tarefas e desenvolveremos este projeto. Ao final, teremos uma base de dados totalmente tratada, pronta para ser utilizada em um modelo de Machine Learning.

Bônus: Exercícios Práticos e Soluções

Além disso, como um bônus, o curso incluirá uma lista de exercícios que poderá ser baixada e será disponibilizada em uma atividade como um PDF. Nessa lista de exercícios, será possível praticar o que foi aprendido durante a aula, fixar os conhecimentos e entender ainda mais como realizar o processo de limpeza e tratamento dos dados. A lista de exercícios incluirá uma outra base de dados para ser utilizada, permitindo entender como realizar esse processo em outros formatos, sem se limitar a um único tipo de dado.

Vídeo de Solução de Atividades

Como um bônus adicional, haverá um vídeo mostrando como solucionar uma das atividades. Isso será muito interessante para que possamos treinar, praticar e aprimorar ainda mais nosso conhecimento nessa tarefa de limpeza e tratamento de dados.

Apresentação do Instrutor

Para quem não me conhece, sou João.

Audiodescrição: João é um homem branco com cabelo e barba curtos. Ele veste uma camisa preta.

Eu estarei acompanhando vocês durante todo este curso. Vamos começar?

Encontrando dados faltantes - Escaneando dados com LazyAPI

Desafio de Perda de Clientes e Preparação de Dados

Uma empresa de telecomunicações enfrenta um grande desafio de perda de clientes. Para conhecer melhor esses clientes e evitar essa perda, a empresa decidiu implementar um modelo de Machine Learning que realize a previsão de churn. No entanto, a base de dados que será utilizada possui muitas inconsistências, dados faltantes e também dados com formato inadequado. Além disso, é uma base de dados muito extensa que requer um grande poder de processamento.

Limpeza e Tratamento de Dados

Nosso papel neste projeto é realizar a limpeza e o tratamento desses dados para que possam ser utilizados no modelo de Machine Learning. Mas como podemos realizar essa limpeza e tratamento de forma otimizada, considerando que se trata de uma base de dados muito extensa?

Utilização da Biblioteca Polars

Vamos utilizar a biblioteca Polars, que é muito eficiente em trabalhar com um grande volume de dados. Com o Google Colab aberto, o primeiro passo é fazer o upload do arquivo que será utilizado como nossa base de dados. Para isso, selecionamos à esquerda o menu de arquivos, clicamos no botão "Fazer Upload para armazenamento da sessão" e selecionamos o arquivo disponível na atividade "Preparando Ambiente". Antes de iniciar o projeto, é importante fazer o download desse arquivo.

Importação e Leitura de Dados

Após clicar duas vezes no arquivo, uma barra circular abaixo indicará o upload do arquivo. Enquanto o arquivo está sendo carregado no Colab, vamos importar a biblioteca que utilizaremos, que é a Polars. Na primeira célula, escrevemos:

import polars as pl

Essa biblioteca já está instalada no Colab, então basta escrever esse código e pressionar Ctrl + Enter para executá-lo.

Escaneamento da Base de Dados

Na segunda célula, faremos a leitura da base de dados, mas é importante aguardar o término do carregamento antes de executar a célula. Podemos já digitar o código responsável por realizar essa leitura. Utilizaremos uma ferramenta muito interessante da biblioteca Polars, que é a Lazy API. Essa Lazy API permite que utilizemos bases de dados mais extensas de forma otimizada. Em vez de carregar toda a base de dados para a memória, ela utiliza queries para fazer consultas na base de dados e retorna o resultado somente quando necessário.

Após o carregamento da base de dados, podemos clicar nos três pontos ao lado do nome do arquivo e selecionar a opção "Copiar Caminho". Feito isso, podemos fechar o menu lateral de arquivos e, na próxima célula, escrever o código que fará o escaneamento dessa base de dados. Não faremos a leitura para a memória, mas sim um escaneamento em que o Polars consegue fazer essa query para consultas à base de dados. Para isso, escrevemos:

dados = pl.scan_csv('/content/dados_churn.csv')

Visualização Inicial dos Dados

A diferença entre a função scan_csv e a função read_csv é que a função read_csv faz a leitura da base de dados e armazena toda a base em memória, utilizando a memória RAM do computador.

No caso do scan_csv, ele escaneia o formato e a estrutura da base de dados, retornando uma query que permite realizar consultas a partir dessa base. Vamos executar essa célula com Ctrl + Enter. Na próxima célula, verificaremos o que foi armazenado na variável dados. Escrevemos:

dados

E pressionamos Ctrl + Enter para executar.

O retorno é um Navy Query Plan que executa um Lazy Frame. Armazenamos nossa base de dados em um Lazy Frame, que mostra um grafo para visualizar a versão otimizada dessa query. Até o momento, ele apenas escaneou todo o conteúdo da base de dados. O pi * 20 indica que ele está selecionando todas as colunas da base de dados, totalizando 20 colunas. No entanto, ainda não conseguimos visualizar a base de dados. Como podemos visualizar esses dados? Precisamos retornar o resultado em memória para visualizar as informações.

Otimização e Coleta de Dados

Podemos escrever:

dados.head(5).collect()

Para otimizar uma query que retorna apenas os cinco primeiros resultados. Executando essa célula com Ctrl + Enter, a query é otimizada para retornar apenas os cinco primeiros resultados e, com o collect, o resultado é exibido na tela.

Agora, temos uma visualização inicial da base de dados, com todas as colunas, o tipo de cada coluna e as informações de cada linha. Para visualizar de forma resumida o nome de todas as colunas e os primeiros elementos, podemos utilizar a função glimpse. Na próxima célula, utilizamos:

dados.collect().glimpse()

Ao executar com Ctrl + Enter, ele retorna a quantidade de linhas na base de dados, que é mais de um milhão, 20 colunas, e exibe o nome de cada coluna, o tipo de dado e os dez primeiros registros. Assim, temos uma ideia geral da nossa base de dados.

Análise das Colunas e Próximos Passos

Incluímos um texto em Markdown com as principais informações sobre cada coluna. Temos informações sobre o cliente, serviço de telefonia, serviço de internet e conta. Cada coluna indica uma informação diferente. Por exemplo, a coluna de churn indica se o cliente deixou de assinar o serviço, com valor 1 para sim e 0 para não. A coluna de gênero indica masculino ou feminino. Temos também a informação de idoso, se o cliente tem idade superior a 65 anos, parceiro, se o cliente possui uma parceira ou parceiro, dependentes, se o cliente possui dependentes, e assim por diante.

Agora, temos uma visão geral de cada informação e podemos compreender como realizar os tratamentos dessa base de dados em relação a cada coluna. Nossa tarefa agora é realizar a limpeza e o tratamento dessa base de dados para que ela possa ser utilizada em um modelo que fará a previsão da coluna de churn. Vamos começar esse tratamento no próximo vídeo.

Encontrando dados faltantes - Encontrando a quantidade de dados nulos

Escaneamento e Resumo da Base de Dados

Já conseguimos realizar o escaneamento da nossa base de dados utilizando a Lazy API da biblioteca Polars, que otimiza o processo de manipulação dos dados. Utilizamos a função glimpse para retornar um resumo com o nome das colunas, o tipo dessas colunas e os dez primeiros registros de cada uma delas na base de dados.

Início do Processo de Limpeza e Tratamento

Agora, podemos iniciar o processo de limpeza e tratamento da nossa base de dados. Como podemos realizar esse processo de forma otimizada usando Polars? E qual seria o primeiro passo no tratamento da nossa base de dados? Podemos começar tratando os dados nulos, mas antes precisamos detectar quais colunas possuem dados nulos para saber em quais delas faremos o tratamento.

Detecção de Dados Nulos

Para isso, podemos percorrer cada uma das colunas da base de dados e, a partir daí, somar ou contar os dados nulos em cada uma delas. Vamos construir uma tabela mostrando a quantidade de dados nulos para cada coluna da nossa base de dados. Primeiro, precisamos apenas dos nomes das colunas. Se tivéssemos lido a base de dados e armazenado em memória usando a função read_csv, bastaria escrever dados.columns. No entanto, se executarmos esse código com Ctrl + Enter, a biblioteca Polars indica que isso pode causar um problema de desempenho. Utilizar o método dados.columns em um LazyFrame envolve resolver primeiro todo o DataFrame e depois coletar apenas o nome das colunas, o que não é otimizado.

Otimização com collect_schema

Para realizar essa tarefa de forma otimizada, podemos utilizar dados.collect_schema(). Dessa maneira, Polars otimiza o processo, constrói uma query para coletar apenas o nome das colunas e retorna isso de forma mais rápida. Com isso, obtemos o nome das colunas e também o tipo dessas colunas. A estrutura resultante está em formato de lista. Vamos percorrer essa lista e coletar o nome das colunas para contar os dados nulos em cada uma delas.

Seleção e Contagem de Dados Nulos

Vamos realizar a seleção na base de dados na próxima célula. Para isso, podemos utilizar dados.select para fazer uma seleção. Nessa seleção, utilizaremos uma list comprehension (compreensão de lista) que fará o processo de utilização da lista que acabamos de extrair, chamada collect_schema.

Primeiro, vamos iniciar a seleção com o método select:

dados.select(
    
)

Agora, vamos implementar um for dentro da seleção para percorrer cada uma das colunas presentes na lista collect_schema. Estamos criando uma list comprehension que percorrerá cada uma das colunas presentes nessa lista:

dados.select(
    [
        for coluna in dados.collect_schema()
    ]
)

Em cada uma dessas colunas, preencheremos um valor na seleção da nossa função, aqui do Polars. Antes do for, colocaremos pl.col para fazer a seleção da coluna. Abrimos parênteses e escrevemos a variável coluna, que está sendo percorrida pelo for:

dados.select(
    [pl.col(coluna) for coluna in dados.collect_schema()]
)

Em cada uma dessas colunas, primeiro verificaremos se existe algum dado nulo. Para isso, utilizamos .is_null(). Em seguida, aplicamos .sum() para somar a quantidade de dados nulos nessa coluna. Ao final, podemos usar .alias(coluna) para dar um nome à coluna que estamos construindo:

dados.select(
    [pl.col(coluna).is_null().sum().alias(coluna) for coluna in dados.collect_schema()]
).collect()

Execução e Resultados

Após realizar a seleção, finalizamos com .collect(). Sempre que utilizarmos um lazy frame da biblioteca Polars, precisamos usar collect para retornar o resultado após a execução da query. Apenas com o select, não obtemos o resultado; ele apenas constrói a query para buscar as informações. Quando aplicamos o .collect(), o resultado da query é retornado na tela.

Vamos executar com Ctrl + Enter. O resultado será uma tabela contendo a quantidade de nulos para cada coluna. Por exemplo, na coluna churn, existem muitos dados nulos, totalizando 25.336. Já nas colunas gênero, idoso e parceiro, não há dados nulos. Encontramos novamente dados nulos na coluna tempo de serviço e, ao mover a tela para a direita, também nas colunas mensal e total.

Próximos Passos

Precisaremos realizar um tratamento diferente para cada uma dessas colunas, começando pela coluna churn. Iniciaremos esse processo no próximo vídeo.

Sobre o curso Polars: limpando e tratando dados

O curso Polars: limpando e tratando dados possui 153 minutos de vídeos, em um total de 53 atividades. Gostou? Conheça nossos outros cursos de Data Science em Data Science, ou leia nossos artigos de Data Science.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Encontrando dados faltantes
• Tratando valores numéricos
• Tratando dados categóricos
• Tratando outliers
• Transformando variáveis binárias