Regressão: aprimorando os resultados com XGBoost

Obtendo os dados - Apresentação

Olá! Que tal se aprofundar no uso de árvores de decisão para resolver problemas de regressão em Machine Learning? Eu sou a Valquíria Alencar, instrutora da Escola de Dados aqui na Alura, e irei te acompanhar ao longo deste curso!

Audiodescrição: Valquíria se descreve como uma mulher branca de olhos castanhos, cabelos castanhos e lisos abaixo dos ombros, com mechas loiras nas pontas. Ela usa piercing no septo, veste uma blusa preta com o logotipo verde da Escola de Dados, e está sentada no estúdio da Alura, com uma parede clara ao fundo iluminada em gradiente de verde para roxo, e uma estante preta à esquerda da instrutora com enfeites, quadros, e pontos de iluminação amarela.

O que vamos aprender?

Neste curso, iremos nos aprofundar em uma técnica chamada boosting. Para entender e aplicar essa técnica, utilizaremos uma biblioteca muito conhecida em Machine Learning: a XGBoost.

Essa biblioteca tem a capacidade de combinar várias árvores de decisão, sempre minimizando os erros para chegar no resultado final mais robusto e interessante possível.

Para fazer tudo isso e compreender como a biblioteca funciona, criaremos um projeto para uma concessionária de veículos, que nos pediu para criar um modelo que faça a precificação de automóveis usados.

Sendo assim, pegaremos os dados necessários para criar esse modelo, o qual será validado, e aprenderemos também a otimizar o modelo, ajustando hiperparâmetros para ter um modelo cada vez mais confiável para o processo.

Para que você consiga acompanhar bem o conteúdo, recomendamos ter conhecimentos em Python e também em algoritmos de árvores de decisão.

Tudo pronto para começar? Nos encontramos no próximo vídeo!

Obtendo os dados - Importando os dados

Vamos dar início ao nosso projeto?

Importando os dados

Neste projeto, atuaremos como cientistas de dados de uma grande concessionária de veículos que vende automóveis usados. A concessionária enfrenta alguns problemas para precificar esses automóveis usados. A precificação está atrelada a diversos fatores, como:

• O ano de fabricação do veículo;
• A quilometragem;
• A marca;
• O modelo;
• Entre outros.

Para facilitar esse processo de precificação, a ideia é criar um modelo de Machine Learning capaz de prever os valores dos automóveis com base nas características que eles possuem.

Para isso, utilizaremos uma biblioteca muito especial em Machine Learning: a biblioteca XGBoost, muito utilizada em competições de Machine Learning e costuma apresentar resultados bem interessantes.

Porém, antes de começar, precisamos importar nossos dados. Com o ambiente do Google Colab aberto, carregaremos os dados para analisar o que temos e fazer alguns tratamentos antes de criar o modelo.

Importando a biblioteca Pandas

Para começar, vamos importar a biblioteca Pandas para carregar os dados. Na primeira célula de código, adicionaremos o seguinte comando:

import pandas as pd

Coletando o endereço do GitHub

Feito isso, vamos pegar um endereço do GitHub que contém os dados com os quais vamos trabalhar. No GitHub, temos os dados no formato CSV, separados por vírgulas. A ideia é copiar o endereço e colar no Google Colab.

Para isso, clicaremos na opção "Raw", no canto superior direito da tela, para obter os dados brutos. Feito isso, basta copiar o endereço diretamente da barra de navegação e colar em uma nova célula no Google Colab.

Podemos criar a variável url para armazenar esse endereço.

url = 'https://raw.githubusercontent.com/alura-cursos/regressao_boosting/main/Dados/dados_automoveis.csv'

Fazendo a leitura do endereço do GitHub

Agora podemos fazer a leitura do endereço. Para isso, começaremos armazenando o resultado gerado em uma variável chamada df (referente a DataFrame), e utilizar a função read_csv() da biblioteca Pandas (pd) para ler o arquivo. Entre os parênteses da função, basta passar a variável url.

df = pd.read_csv(url)

Visualizando os cinco primeiros resultados do DataFrame

Após executar a célula, podemos verificar as informações que temos e quais são as variáveis desse conjunto de dados. Para isso, usaremos a função head(), que irá ler as 5 primeiras linhas de df.

df.head()

Como retorno da célula, recebemos a seguinte tabela:

As colunas contêm: a marca do automóvel; o modelo do automóvel; o ano de fabricação; o tipo de combustível; a potência do motor; a quantidade de cilindros do motor; o tipo de transmissão; as rodas motrizes (em relação à tração); o número de portas; o tamanho do automóvel; o estilo do automóvel; o consumo na estrada (em milhas); o consumo na cidade (também em milhas); e, por fim, a coluna de grande interesse, contendo o valor do automóvel (em dólares), que é o que iremos prever no futuro.

Agora, precisamos entender como os dados estão organizados, se está tudo correto, ou se precisamos fazer alguma transformação neles antes de iniciar o modelo efetivamente.

Verificando mais informações sobre os dados

Podemos verificar mais informações utilizando o método info(). Em uma nova célula, adicionaremos o seguinte comando:

df.info()

Retorno da célula

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 10918 entries, 0 to 10917
Data columns (total 14 columns):
 #   Column                  Non-Null Count  Dtype  
---  ------                  --------------  -----  
 0   Marca                   10918 non-null  object 
 1   Modelo                  10918 non-null  object 
 2   Ano                     10918 non-null  int64  
 3   Tipo_combustivel        10918 non-null  object 
 4   Potencia_motor          10862 non-null  float64
 5   Cilindros_motor         10888 non-null  float64
 6   Tipo_transmissao        10918 non-null  object 
 7   Rodas_motrizes          10918 non-null  object 
 8   Numero_portas           10916 non-null  float64
 9   Tamanho                 10918 non-null  object 
 10  Estilo                  10918 non-null  object 
 11  Consumo_estrada_milhas  10918 non-null  int64  
 12  Consumo_cidade_milhas   10918 non-null  int64  
 13  Valor($)                10918 non-null  int64  
dtypes: float64(3), int64(4), object(7)
memory usage: 1.2+ MB

Em relação ao número de automóveis desse DataFrame, temos 10.918 linhas, ou seja, bastante informação. No total, são 14 colunas, e temos também informações em relação a dados nulos e não nulos em cada uma das colunas. Além disso, são exibidos os tipos de dados de cada coluna.

Por exemplo: temos Marca e Modelo definidas com o tipo object, pois são strings, em formato de texto. Já o Ano do automóvel é do tipo int64, enquanto Potencia_motor e Cilindros_motor recebem o tipo float64.

Conclusão

Agora que entendemos quais tipos de dados temos e quais são as colunas, precisamos refletir se será necessário fazer algum tratamento para colocar esses dados dentro do modelo.

Será que o modelo aceita dados do tipo object? Será que temos valores duplicados entre as mais de 10 mil entradas e precisamos fazer algum processamento nos dados?

No próximo vídeo, falaremos sobre isso com calma e realizaremos alguns processos para tratar esses dados. Nos encontramos lá!

Obtendo os dados - Processando os dados

Neste vídeo, iremos tratar os dados e prepará-los para o modelo.

Processando os dados

No vídeo anterior, verificamos as informações e observamos que algumas colunas tinham dados nulos. Será que precisamos fazer algum tratamento?

A depender do algoritmo de Machine Learning utilizado para criar o modelo, o tratamento será necessário. No caso do XGBoost, biblioteca que iremos utilizar, ela consegue lidar internamente com os dados nulos, então não precisamos fazer nenhum tratamento ou substituição de valores.

Nossa ideia, portanto, é prosseguir sem fazer tratamento dos dados nulos.

No entanto, pode ser que haja dados duplicados, e isso seria interessante tratar, pois pode trazer algum viés para o modelo de ter várias informações repetidas.

O modelo pode se acostumar com isso e, quando vier alguma informação diferente, não lidar tão bem como esperado. Assim, tentaremos evitar todo tipo de viés e retirar linhas possivelmente duplicadas.

Verificando dados duplicados

Como verificamos duplicações, ou seja, se existem linhas duplicadas no DataFrame? Há uma função que podemos utilizar para isso: após df, chamaremos a função duplicated() seguida de sum(), para somar se houver alguma duplicação. Assim, obteremos a quantidade de linhas duplicadas.

df.duplicated().sum()

Ao executar a célula, temos como resultado 709 linhas que estão realmente duplicadas. O próximo passo será fazer a remoção disso e manter apenas o primeiro registro da informação.

Removendo dados duplicados

Em uma nova célula, criaremos uma variável para armazenar os dados já limpos. Podemos chamá-la de dados_limpos, e ela será igual ao df seguido da função drop_duplicates() para remover as duplicatas.

Além disso, podemos resetar o índice. Quando removemos os dados duplicados, o índice não fica ordenado corretamente. A ideia é resetar para deixar tudo organizado novamente. Para isso, vamos chamar dados_limpos na linha abaixo, seguida do método reset_index().

Entre os parênteses do método, passaremos as seguintes informações: drop igual a True, para realizar o processo; e inplace igual a True, para que o processo seja feito no DataFrame df sem precisar criar um novo DataFrame. Dessa forma, iremos sobrescrever ele.

dados_limpos = df.drop_duplicates()
dados_limpos.reset_index(drop=True, inplace=True)

Após executar essa célula, teremos a remoção.

Verificando a quantidade de registros

Em uma nova célula, podemos chamar a variável dados_limpos seguida de shape para verificar quantos registros temos após remover as duplicatas.

dados_limpos.shape

Retorno da célula

(10209, 14)

Agora temos 10.209 linhas e continuamos com as 14 colunas. Portanto, realmente conseguimos remover as informações duplicadas.

Transformando os dados

Na sequência, precisamos trabalhar outro ponto. Se voltarmos para o retorno do método info(), encontramos várias colunas com o tipo objeto (object), ou seja, há um texto nessa coluna.

O problema é que, em um modelo de Machine Learning, os algoritmos usados não conseguem passar dados do tipo object. Precisamos fazer alguma transformação para que o valor seja entendível pelo modelo.

O XGBoost tem capacidade de trabalhar com dados categóricos de uma forma diferente. Não precisamos, por exemplo, realizar os processos conhecidos como one-hot-encoding, nos quais criamos uma coluna para cada categoria.

Isso deixaria a matriz de dados gigante, pois aumentaria muito o tamanho do conjunto de dados, uma vez que devemos ter colunas contendo várias categorias.

Dito isso, nossa ideia é transformar o tipo de objeto objeto em um tipo de categoria (category), que o XGBoost consegue entender e facilitará muito o nosso processo.

Em uma célula vazia, criaremos um novo DataFrame a partir de uma cópia de dados_limpos, de modo que ele continue existindo e nada seja sobrescrito nele.

Chamaremos esse novo DataFrame de df_final, visto que faremos isso apenas para finalizar antes de começar o modelo. Ele será igual a dados_limpos seguido do método .copy() para fazer a cópia.

df_final = dados_limpos.copy()

Delimitando as colunas

Na próxima linha da mesma célula, vamos separar as colunas do tipo object para deixar bem delimitado, e depois iremos alterar o tipo delas.

Primeiro, criaremos uma variável chamada object_columns, que será igual ao DataFrame df_final seguido de algumas informações. Para selecionar o tipo de dado, usaremos o método select_dtypes().

Entre parênteses, vamos especificar que queremos incluir (include) apenas o tipo object. Na sequência, usaremos columns para fazer a seleção somente das colunas do tipo object.

df_final = dados_limpos.copy()

object_columns = df_final.select_dtypes(include='object').columns

Alterando o tipo das colunas

Para finalizar, na próxima linha, vamos chamar df_final para especificar que falamos apenas das colunas do tipo object, então abrimos colchetes e passamos object_columns.

Após o igual (=), chamaremos novamente o DataFrame df_final, especificando entre colchetes as colunas do tipo objeto (object_columns), mas agora vamos mudar o tipo delas.

Para isso, usaremos o método astype(), recebendo entre parênteses o tipo category, que a biblioteca Pandas consegue converter. Dessa forma, transformamos object em category.

df_final = dados_limpos.copy()

object_columns = df_final.select_dtypes(include='object').columns
df_final[object_columns] = df_final[object_columns].astype('category')

Podemos visualizar se o resultado funcionou com o seguinte comando:

df_final.dtypes

Retorno da célula

Ao executar, verificamos que tudo funcionou e recebemos a marca, o modelo, o tipo de combustível, o tipo de transmissão, as rodas motrizes, o tamanho e o estilo, todos com o tipo category.

Conclusão

Com isso, conseguimos trabalhar muito bem com o XGBoost. Na próxima aula, começaremos a criar o modelo e a fazer nossas primeiras previsões!

Sobre o curso Regressão: aprimorando os resultados com XGBoost

O curso Regressão: aprimorando os resultados com XGBoost possui 146 minutos de vídeos, em um total de 45 atividades. Gostou? Conheça nossos outros cursos de Machine Learning 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:

• Obtendo os dados
• Utilizando o XGBoost
• Realizando a validação do modelo
• Ajustando hiperparâmetros do XGBoost
• Finalizando o modelo