Polars: analisando dados de forma eficiente

Conhecendo os dados - Apresentação

Você já precisou trabalhar com uma grande quantidade de dados, mas não sabe qual é a forma mais eficiente de lidar com esse volume de informações?

Neste curso, vamos construir um projeto prático de análise exploratória de dados utilizando a biblioteca Polars, que é muito eficiente para trabalhar com grandes volumes de dados.

Audiodescrição: João Miranda é um homem de pele clara de olhos e cabelos castanhos escuros. Está de barba rente ao rosto e com uma camiseta azul. Ao fundo, parede com iluminação azul.

O que vamos desenvolver?

Ao longo do projeto, analisaremos uma base de dados de restaurantes, contendo informações sobre preço médio, cardápio e análises deixadas por clientes. Nosso objetivo é extrair insights e criar nossa própria rede de restaurantes baseada em dados.

Ao final do curso, seremos capazes de construir um relatório detalhado com análises textuais e tabulares, além de gráficos e nuvens de palavras que nos ajudarão a entender esses dados.

Para isso, trabalharemos com a limpeza, tratamento e transformações dos dados, bem como a criação de visualizações, como gráficos e nuvens de palavras.

Pré-requisitos

Durante este curso, focaremos na tarefa de análise de dados. Portanto, o treinamento de modelos de Machine Learning não será abordado.

Para acompanhar este conteúdo, é necessário ter conhecimento na linguagem de programação Python, que será utilizada ao longo do projeto.

Vamos começar?

Conhecendo os dados - Realizando a leitura dos dados

Uma equipe de empreendedores deseja abrir uma nova franquia de restaurantes e quer tomar decisões estratégicas baseadas em dados. Para isso, querem entender o mercado, os padrões de consumo e analisar os pontos fortes e fracos dos restaurantes para reconhecer as preferências da clientela.

Nosso papel neste projeto é criar um relatório e enviá-lo para essa equipe, contendo evidências e informações que conseguimos extrair a partir dos dados para auxiliar na tomada de decisão da criação dessa nova rede de restaurantes.

Como a base de dados é extensa, precisamos de uma forma eficiente de trabalhar com esses dados. Por isso, utilizaremos a biblioteca Polars, que é muito eficiente em lidar com um grande volume de informações.

Primeiramente, é preciso importar essa biblioteca no ambiente do Colab e carregar os dados.

Importando biblioteca Polars

Vamos começar pela importação da biblioteca Polars, uma vez que ela já está instalada no Colab. Na primeira célula, escrevemos:

import polars as pl

Executamos a célula com "Ctrl + Enter". Com isso, já importamos essa biblioteca, cujo ponto forte é trabalhar com um grande volume de dados.

Realizando leitura dos dados

Agora, precisamos fazer a leitura da base de dados. A base de dados já está no Google Drive, então, para carregá-la, clicamos no ícone de "Arquivos" na lateral esquerda no Google Colab e selecionamos a opção "Montar drive". Na janela que se abre, vamos clicar no botão "Conectar ao Google Drive" para permitir que o notebook acesse nossos arquivos.

O arquivo com a base de dados está disponível na atividade "Preparando o Ambiente" antes deste vídeo. É importante fazer o download desse arquivo e fazer o upload para o ambiente do Colab ou colocá-lo no Google Drive.

Desse modo, poderemos copiar o caminho do arquivo que está em uma pasta no Google Drive. Após montar o Drive, basta acessar a pasta "Drive > MyDrive" e localizar a base de dados restaurantes.csv. Clicamos nos três pontos à direita desse arquivo e selecionamos a opção "Copiar caminho". Podemos fechar o menu lateral esquerdo e proceder com a leitura da base de dados em uma nova célula.

Para isso, criamos uma variável chamada restaurantes que será igual à função plt.read_csv(). Entre parênteses e aspas, vamos pressionar o atalho "Ctrl + V" para colar o caminho do arquivo da base de dados como primeiro parâmetro.

O segundo parâmetro será o enconding igual a utf-8, entre aspas. Assim, conseguiremos decodificar as informações com acentos e outros caracteres especiais.

restaurantes = pl.read_csv('/content/drive/MyDrive/dados/restaurantes.csv', encoding='utf-8')

Executamos a célula com "Ctrl + Enter". A leitura do arquivo pode demorar um pouco, já é uma base de dados extensa. Ainda assim, a biblioteca Polars é bem eficiente na leitura de tantos dados.

Após a leitura, na próxima célula, escrevemos o nome da variável restaurantes e executamos com "Ctrl + Enter" para visualizar os dados.

restaurantes

Obtemos um dataframe, que é a informação principal na biblioteca Polars, que permite trabalhar com dados tabulares. Assim, já conseguimos visualizar o nome de cada uma das colunas, o tipo dessas colunas e as informações de cada uma delas.

Explorando os dados

Existe uma outra forma de visualizar esses dados para entender o formato e o nome das colunas, que é o método glimpse(). Na próxima célula, escrevemos

restaurantes.glimpse()

Saída:

Rows: 51717  
Columns: 13

$ name                        <str> 'Jalsa', 'Spice Elephant', 'San Churro Cafe', 'Addhuri Udupi Bhojana'  
$ online_order                <str> 'Yes', 'Yes', 'Yes', 'No'  
$ book_table                  <str> 'Yes', 'No', 'No', 'No'  
$ rate                        <str> '4.1/5', '4.1/5', '3.8/5', '3.7/5'  
$ votes                       <i64> 775, 787, 918, 88  
$ rest_type                   <str> 'Casual Dining', 'Casual Dining', 'Cafe, Casual Dining', 'Quick Bites'  
$ dish_liked                  <str> 'Pasta, Lunch Buffet, Masala Papad', 'Momos, Lunch Buffet, Chocolate Nirvana', 'Churros, Cannelloni, Minestrone  Soup', 'Masala Dosa'  
$ cuisines                    <str> 'North Indian, Mughlai, Chinese', 'Chinese, North Indian, Thai', 'Cafe, Mexican, Italian', 'South Indian, North Indian' 
$ approx_cost(for two people) <str> '800', '800', '800', '300'  
$ reviews_list                <str> "[('Rated 4.0', 'RATED\\n  A beautiful place...')]", "[('Rated 4.0', 'RATED\\n  Had been here for dinner...')]", "[('Rated 3.0', 'RATED\\n  Ambience is not that good...')]", "[('Rated 4.0', 'RATED\\n  Great food and proper Karnataka style...')]"  
$ menu_item                   <str> '[]', '[]', '[]', '[]'  
$ listed_in(type)             <str> 'Buffet', 'Buffet', 'Buffet', 'Buffet'  
$ listed_in(city)             <str> 'Banashankari', 'Banashankari', 'Banashankari', 'Banashankari'  

Dessa forma, teremos uma visualização mais limpa. Com isso, descobrimos que existem 51.717 linhas e 13 colunas no dataframe, bem como o nome de cada uma delas.

Vamos entender quais informações temos a respeito dos dados:

• Nome do restaurante (name): texto do nome do restaurante;
• Pedido online (online_order): texto que indica se o restaurante faz entregas online;
• Reserva de mesa (book_table): texto que indica se o restaurante aceita reservas;
• Nota média (rate): texto que representa a nota do restaurante em uma escala de 1 a 5;
• Votos (votes): número inteiro que representa a quantidade de análises deixadas por clientes;
• Tipo do restaurante (rest_type): texto que indica a categoria do restaurante;
• Pratos preferidos (dish_liked): texto com a lista os pratos mais apreciados pela clientela;
• Culinária (cuisines): texto que representa os tipos de cozinha oferecidos pelo restaurante;
• Custo aproximado (approx_cost(for two people)): texto que representa o preço médio para duas pessoas;
• Lista de avaliações (reviews_list): texto com a lista de análises deixadas pelos clientes;
• Itens do cardápio (menu_item): texto que representa o cardápio dos restaurantes;
• Classificação por tipo (listed_in(type)): texto que categoriza os restaurantes por tipo;
• Classificação por cidade (listed_in(city)): texto que indica a cidade onde o restaurante está localizado.

Além disso, podemos notar que a biblioteca Polars não cria uma indexação para a tabela de forma explícita. Nos dados originais, não existe informação numérica de qual é o primeiro elemento, segundo e assim por diante. Quando o Polars faz a leitura da base de dados, ele não insere essas informações de indexação, mas as informações estão em ordem e ainda podemos ainda coletar informações baseadas nesse índice implícito. Essa é uma diferença da biblioteca Polars para a biblioteca Pandas, por exemplo, que já cria essa indexação de forma explícita.

Próximos passos

Agora que conseguimos fazer o carregamento desses dados e entendemos o tipo de cada coluna, percebemos que precisaremos fazer alguns tratamentos. Por exemplo, a coluna de rate que contém a avaliação de clientes está em formato de texto, mas seria mais interessante se estivesse no formato numérico.

O mesmo vale para approx_cost(for two people) que contém o custo aproximado para duas pessoas. Os dados estão no formato de texto, mas é uma informação que precisa ser analisada numericamente.

No próximo vídeo, começaremos com a transformação de dados para fazer o tratamento das colunas.

Conhecendo os dados - Convertendo valores numéricos

Para definir o posicionamento estratégico de uma rede de restaurantes, é essencial compreender a distribuição dos preços dos restaurantes. Isso nos permitirá identificar preço de acordo com a média, o valor mínimo e máximo, mantendo-nos competitivos no mercado.

No entanto, durante a exploração inicial dos dados, observamos que a coluna que contém o preço aproximado para duas pessoas está em formato textual. Isso impede a extração de estatísticas e a análise da distribuição desses dados para entregar um bom resultado.

Como podemos transformar esses dados para o formato numérico? Primeiramente, devemos investigar a coluna para entender por que a biblioteca Polars não conseguiu interpretar essas informações como numéricas. A partir daí, definiremos a estratégia para realizar essa transformação.

Convertendo valores numéricos

A coluna approx_cost(for two people) do dataframe representa o preço aproximado para duas pessoas. Em algumas entradas, encontramos dados como 800, 300 e 1,500 - todos entre aspas, já que estão em formato de texto. A vírgula para fazer a separação de milhar pode ter impedido a biblioteca Polars de reconhecer esses valores como números.

Portanto, precisamos remover essa vírgula para transformar a coluna para o formato numérico. Como podemos realizar essa transformação?

Na primeira célula, utilizaremos um método da biblioteca Polars para transformar colunas chamado with_columns(). A partir do dataframe restaurantes, aplicaremos o método with_columns(), especificando as colunas que desejamos transformar.

Nesse caso, focaremos na coluna que contém o custo aproximado para duas pessoas. Para coletar essa coluna, utilizaremos pl.col(), que é o alias da biblioteca Polars seguido da função col() que coleta a informação da coluna. Basta passar o nome da coluna entre aspas. Vamos copiar o nome da coluna approx_cost(for two people) e colá-lo.

restaurantes.with_columns(
    pl.col('approx_cost(for two people)')
)

Dentro do with_columns(), podemos realizar a transformação da coluna. Nesse caso, queremos remover a vírgula dos textos dessa coluna.

A partir do pl.col(), vamos acrescentar .str, que acessa métodos para transformar strings. Em seguida, acessaremos o método chamado replace() que irá substituir a vírgula por um espaço vazio. Por isso, o primeiro parâmetro da função será a vírgula, entre aspas; e o segundo será um espaço vazio, entre aspas.

restaurantes.with_columns(
    pl.col('approx_cost(for two people)')
    .str.replace(',', '')
)

Com isso, já não teríamos mais a vírgula como separador de milhar dos valores na coluna approx_cost(for two people). No entanto, esses valores ainda estão em formato de string.

Para transformar seu formato, ainda dentro do método with_columns(), acrescentaremos a função .cast(), que é responsável fazer a transformação de tipagem no Polars. Queremos converter de string para float, o formato numérico decimal. Para isso, dentro do cast(), especificaremos pl.Float64, com a letra "F" em maiúsculo.

restaurantes.with_columns(
    pl.col('approx_cost(for two people)')
    .str.replace(',', '')
    .cast(pl.Float64)
)

Agora, a coluna approx_cost(for two people) está no formato f64, ou seja, em float. Os números não têm mais aspas e apresentam um ponto zero no final. Isso significa que conseguimos exibir a coluna transformada para o formato numérico.

Para realmente aplicar essa transformação no dataframe, precisamos substituir o dataframe original pela informação que acabamos de visualizar. É importante visualizar primeiro, para verificar se o código está corretamente, para só então fazer a transformação na base de dados original.

Vamos copiar o código que construímos e, na próxima célula, escrever o seguinte: restaurante será igual ao código da visualização que construímos. Desse modo, substituímos o dataframe por um novo dataframe com a coluna transformada.

restaurantes = restaurantes.with_columns(
    pl.col('approx_cost(for two people)')
    .str.replace(',', '')
    .cast(pl.Float64)
)

Depois de essa célula, o dataframe estará transformado.

Coletando estatísticas

Para visualizar estatísticas a respeito dessas informações, como o preço mínimo, máximo e a média dos restaurantes, podemos selecionar a coluna correspondente e extrair essas estatísticas.

Na próxima célula, escreveremos restaurantes para acessar o dataframe e utilizaremos um método que selecionará as informações desse dataframe. Não faremos nenhuma transformação, apenas selecionaremos as informações para extrair estatísticas.

Para isso, utilizaremos o método select(). Dentro desse método, vamos especificar a coluna que queremos selecionar e o método estatístico que queremos aplicar nessa seleção.

Basta escrever plt.col(), selecionando a coluna approx_cost(for two people). Para extrair o valor máximo dessa coluna, vamos aplicar o método .max(). Também vamos dar um nome para a coluna dessa nova tabela. Ao final da linha, acrescentamos .alias(), passando o apelido "max", entre aspas.

Podemos usar essa mesma linha para calcular o valor mínimo e médio, pois queremos saber as estatísticas dessa mesma coluna. Vamos acrescentar uma vírgula e duplicar essa linha duas vezes.

Para extrair o valor mínimo, manteremos o plt.col(), mas substituiremos o método para min() e o alias também para "min". Já para extrair a média, vamos substituir o método para mean() e definir o alias como "media".

Como a média pode conter muitas casas decimais, vamos fazer um arredondamento nessa seleção. Logo após o método mean(), vamos digitar .round(), passando o número 2. Assim, teremos apenas duas casas decimais.

restaurantes.select(
    pl.col('approx_cost(for two people)').max().alias('max'),
    pl.col('approx_cost(for two people)').min().alias('min'),
    pl.col('approx_cost(for two people)').mean().round(2).alias('media')
)

Com isso, fizemos a seleção três vezes da mesma coluna, mas aplicamos transformações diferentes. Assim, extraímos o valor máximo, mínimo e a média do custo aproximado de todos os restaurantes.

O valor máximo de preço aproximado para duas pessoas é R$ 6000, o mínimo é R$ 40 e a média é R$ 555. Com base nisso, podemos determinar o valor a ser aplicado nos nossos restaurantes.

Por exemplo, não deveríamos colocar um restaurante com valor menor que R$ 40, pois isso fugiria do padrão geral. Também não deveríamos colocar um restaurante muito caro, acima de R$ 6000, pois isso seria inviável.

Um restaurante com preço próximo à média seria competitivo e atrairia clientes, pois estaria alinhado com os outros restaurantes. No entanto, calculamos a média de preço considerando os restaurantes globais. Qual seria o comportamento do preço se filtrássemos apenas pelos melhores restaurantes?

Próximos passos

Vamos seguir com novas transformações em outras colunas para extrair mais insights. Continuaremos essa análise na próxima aula.

Sobre o curso Polars: analisando dados de forma eficiente

O curso Polars: analisando dados de forma eficiente possui 170 minutos de vídeos, em um total de 54 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:

• Conhecendo os dados
• Realizando transformações nos dados
• Visão geral dos dados
• Filtrando os dados
• Analisando os textos