Classificação: combinando classificadores para a melhoria de performance

Testando modelos clássicos - Apresentação

Olá, boas-vindas a este curso de classificação em Machine Learning da Alura. Sou Allan Spadini e serei o instrutor neste curso.

Audiodescrição: Allan se identifica como um homem branco. Tem cabelos e olhos castanhos. Usa uma camiseta preta. Ao fundo, estúdio da Alura com iluminação azul e estante com decorações à direita.

O que vamos aprender?

Neste curso, trabalharemos com um dataset de classificação da satisfação de passageiros.

Nosso objetivo será obter um bom score de resultado de classificação, mas não apenas um bom score, e sim o melhor resultado possível de classificação no modelo de Machine Learning.

Para isso, estudaremos a combinação de diferentes modelos de classificação e seus resultados.

Ao final deste curso, você será capaz de realizar essa combinação e obter o melhor resultado possível em aplicações de classificação de Machine Learning.

Pré-requisitos

O pré-requisito para acompanhar este curso é que você consiga já aplicar modelos de classificação em Machine Learning.

Esperamos te encontrar nos próximos vídeos deste curso. Até lá!

Testando modelos clássicos - Situação problema

Olá! Vamos começar a estudar esse problema. Imagina que você trabalha em uma empresa de linhas aéreas e a empresa coletou uma série de informações sobre os voos e a satisfação da clientela nesses voos.

Assim, a tarefa que nos foi dada é pegar esse dataset e construir um modelo de Machine Learning (Aprendizado de Máquina). No entanto, não conhecemos o dataset e nem sabemos qual modelo de Machine Learning seria ideal para aplicar nesse problema.

Neste vídeo, vamos iniciar carregando esse dataset e tentando entender o que precisamos fazer com ele e como ficam os primeiros resultados de Machine Learning em cima desse dataset.

Pré-processamento de dados

Vamos disponibilizar os resultados e o dataset através de um repositório do GitHub.

Em um caderno do Google Colab, já temos o link do dataset em duas URLs diferentes. Fizemos a divisão em um dataset de treino e outro de teste.

url1 = 'https://raw.githubusercontent.com/alura-cursos/combina-classificadores/main/dados/train.csv'
url2 = 'https://raw.githubusercontent.com/alura-cursos/combina-classificadores/main/dados/test.csv'

Vamos apertar "Shift + Enter" para executar a célula com o endereço das URLs. Em seguida, vamos importar a biblioteca pandas para poder ler os arquivos.

Vamos fazer o import pandas as pd. Depois, vamos criar a variável treino igual a pd.read_csv(), passando a url1 que é o endereço onde colocamos nosso primeiro dataset.

Assim, teremos os dados de treino na variável treino.

Para os dados de teste faremos o mesmo, criando a variável teste igual a pd.read_csv(url2).

import pandas as pd

treino = pd.read_csv(url1)
teste = pd.read_csv(url2)

Vamos conferir os dados de treino para ter uma ideia geral desse dataset. Para isso, vamos fazer o treino.head().

treino.head()

Estamos exibindo as primeiras cinco linhas desse dataset e temos algumas colunas que talvez tenham que ser removidas, como a unnamed e id, que não são utilizadas no Machine Learning.

Também temos uma série de informações sobre as pessoas passageiras, algumas informações categóricas e outras informações numéricas contínuas.

Por exemplo, o gênero das pessoas, o tipo de consumidor e se a pessoa pegou o voo em uma classe específica.

A última coluna, chamada satisfaction, é a satisfação das pessoas passageiras. Temos dois tipos de satisfação de passageiros, ou seja, estamos trabalhando com o problema de classificação binária: a pessoa gostou ou a pessoa não gostou do voo.

O que precisamos fazer de pré-processamento nesses dados para conseguir trabalhar com o Machine Learning?

Vamos tentar visualizar em maior detalhe as informações desse dataset. Para isso, vamos fazer o treino.info().

treino.info()

<class 'pandas.core.frame.DataFrame'>

RangeIndex: 103904 entries, 0 to 103903

Data columns (total 25 columns):

dtypes: float64(1), int64(19), object(5)

Agora conseguimos verificar em maior detalhe que temos informações do tipo inteiro, float e object. Conseguimos perceber que temos valores do tipo não nulo em cada uma dessas colunas, ou seja, não temos valores nulos especificamente. Mas e valores do tipo None?

Se tentamos aplicar o modelo de Machine Learning com valores do tipo None no dataset, não conseguiremos realizar nenhum tipo de operação. Por isso, precisamos remover esses dados do tipo NA ou None.

Para verificar se existem esses dados do tipo NA, podemos fazer o seguinte comando:

treino.isna().sum()

Conseguimos notar que em nenhuma das linhas existem valores do tipo NA, pois somamos os valores e recebemos o resultado zero - exceto na coluna Arrival Delay in Minutes. Nela, temos 310 valores do tipo NA.

Nesse caso, a ideia para a aplicação será remover as linhas que têm os valores do tipo NA.

Removendo valores n\a e transformando colunas categóricas

Como a remoção deve ser feita tanto nos dados de treino e nos dados de teste, vamos criar uma função para fazer esse processo.

Em uma nova célula, vamos criar a função de nome def prepara(). Essa função vai receber o DataFrame de nome df.

Após os dois-pontos, queremos escrever todo o processamento que devemos fazer no dataset.

Primeiro, é necessário remover algumas colunas que já descobrimos que não são interessantes. Por isso, vamos fazer o df.drop(). Entre colchetes, passamos as colunas Unnamed: 0 e id, ambas entre aspas.

Fora dos colchetes, ainda no drop(), passamos o parâmetro axis=1 para fazer o processamento nas colunas. Por fim, escrevemos inplace=True.

Com isso, já removemos aquelas duas colunas que não eram interessantes no dataset.

Agora, vamos fazer o processo de remoção do NA, digitando df.dropna(), passando inplace=True.

def prepara(df):
    df.drop(['Unnamed: 0', 'id'],axis=1,inplace=True)
    df.dropna(inplace=True)

Também temos colunas categóricas no dataset. Além de remover os dados do tipo NA, precisamos transformar essas colunas categóricas em colunas numéricas.

Para resolver isso, podemos fazer o df igual a pd.get_dummies(). Como parâmetro, vamos passar o df e columns igual à variável colunas_categoricas.

Precisaremos escrever quais são as nossas colunas categóricas. Na linha anterior, vamos digitar que colunas_categoricas vai ser igual a, entre colchetes e aspas, Gender, Customer Type, Type of Travel e Class.

Terminamos o processo de pré-processamento, mas vamos aproveitar para colocar essas informações na variável X e na variável y. A variável X são as nossas variáveis dependentes, e a y, a nossa variável independente, o nosso objetivo de classificação.

Na última linha, colocamos que X é igual a df.drop(), passando a coluna satisfaction entre aspas. Não queremos essa coluna, pois é a variável independente. Como segundo parâmetro, passamos axis=1.

Já o y será igual a df['satisfaction'].

Por fim, vamos retornar esses valores, usando um return X, y.

def prepara(df):
    df.drop(['Unnamed: 0', 'id'],axis=1,inplace=True)
    df.dropna(inplace=True)
    colunas_categoricas = ["Gender", "Customer Type", "Type of Travel", "Class"]
    df = pd.get_dummies(df, columns=colunas_categoricas)
    X = df.drop('satisfaction', axis=1)
    y = df['satisfaction']
    return X,y

Vamos dar "Shift + Enter" para verificar se essa função vai funcionar corretamente. Em seguida, vamos criar um X_treino, y_treino que vai ser igual a função prepara(), passando o DataFrame de treino.

A função deve funcionar tanto para os dados de treino, quanto para os dados de teste. Por isso, vamos copiar a linha do treino, e substituir onde está escrito treino por teste.

X_treino, y_treino = prepara(treino)
X_teste, y_teste = prepara(teste)

E, assim, fazemos todo o processamento nos dados de treino e teste também.

Podemos visualizar os dados de treino executando X_treino:

X_treino

Após dar "Shift + Enter", percebemos que algumas colunas foram removidas e as informações categóricas foram transformadas em números - de acordo com o que precisamos para trabalhar com esses dados e aplicar o Machine Learning.

No próximo vídeo, vamos efetivamente aplicar o modelo de Machine Learning e verificar quais serão os resultados do nosso primeiro teste.

Até o próximo vídeo!

Testando modelos clássicos - Testando as árvores

No último vídeo, realizamos o pré-processamento dos dados e entendemos o dataset dos passageiros. Agora, queremos efetivamente classificar e obter um resultado de classificação para esse dataset.

Para isso, vamos começar aplicando um modelo de classificação baseado nas árvores de decisão.

Árvore de decisão

Neste vídeo, vamos aplicar o modelo de árvores de decisão. Portanto, vamos importar essa função da sklearn.

Em uma nova célula do Colab, vamos escrever:

from sklearn.tree import DecisionTreeClassifier

Após executar com "Shift+Enter", vamos instanciar esse modelo. Para isso, vamos chamá-lo de modelo1, que será igual ao DecisionTreeClassifier().

Entre os parênteses, podemos definir um random_state para que os resultados possam ser replicados. Vamos colocar random_state igual a 42.

modelo1 = DecisionTreeClassifier(random_state=42)

Na sequência, queremos aplicar o modelo de classificação.

Já temos os dados separados em treino e teste, mas vamos usar apenas os dados de treino para fazer uma validação cruzada. Assim, dentro do cross_validate, ele vai fazer uma divisão em treino e validação.

Para conseguir aplicar o cross_validate, vamos importá-lo na célula de cima também. Vamos escrever o seguinte:

from sklearn.model_selection import cross_validate

Agora, precisamos chamá-lo. Para isso, vamos criar uma variável de nome validacao que vai ser igual a cross_validate(), que vai receber o modelo1, o X_treino, o y_treino e cv igual a 5.

validacao = cross_validate(modelo1, X_treino, y_treino, cv=5)

Agora, vamos dar um "Shift + Enter" e esperar um tempo para fazer esse processo de validação.

Após o processo de validação, podemos verificar os resultados de teste feitos internamente. Para isso, usamos a coluna validacao['teste_score'].

validacao['test_score']

array([0.94164776, 0.94603987, 0.9450263, 0.94381968, 0.94521672])

Obtemos o resultado da validação com a validação cruzada. Ele fez 5 testes diferentes com divisões de treino e validação diferentes internamente. Por isso, temos 5 resultados.

Com isso, podemos calcular a média, por exemplo. acrescentando um .mean().

validacao['test_score'].mean()

0.9443500672495754

Desse modo, temos que um resultado médio de validação de 0.94 de taxa de acerto.

Além disso, podemos testar o resultado em cima dos dados de teste, que é um dataset que ele não analisou durante esse ajuste do modelo de classificação de árvores de decisão.

Podemos fazer o modelo1.predict(X_teste). Agora, vamos criar uma previsão de resultado. Criamos a variável y_pred que será igual ao modelo1.predict().

y_pred = modelo1.predict(X_teste)

NotFittedError: This DecisionTreeClassifier instance is not fitted y 'fit' with appropriate arguments before using this estimator.

Um erro ocorre porque ele não tem o modelo1 ajustado aos dados. Mas, para resolver isso, basta treinar o modelo1 com os dados de treino.

Na célula anterior, vamos fazer o modelo1.fit(), passando X_treino e y_treino.

modelo1.fit(X_treino,y_treino)

Agora sim, temos o nosso modelo treinado. Tínhamos feito apenas sua validação, agora treinamos no dataset completo de treino e agora conseguimos testá-lo nos dados de teste.

A seguir, vamos comparar o y_pred com o y_teste. Para fazer essa comparação, vamos importar o sklearn.metrics import accuracy_score.

from sklearn.metrics import accuracy_score

Por fim, chamamos essa função accuracy_score() e passamos o y_teste e o y_pred.

accuracy_score(y_teste,y_pred)

0.94612443517553

Nessa comparação, também temos algo em torno de 0.94 de score como resultado final.

Isso é um resultado de classificação muito bom. Mas testamos um modelo de aprendizado de máquina de forma arbitrária, ou seja, não testamos diversos modelos de machine learning.

Será que tem algum que funciona de forma diferente, funciona pior ou melhor que esse modelo de machine learning?

No próximo vídeo, vamos testar outro modelo de machine learning para ter um critério de comparação dos nossos resultados. Até o próximo vídeo!

Sobre o curso Classificação: combinando classificadores para a melhoria de performance

O curso Classificação: combinando classificadores para a melhoria de performance possui 127 minutos de vídeos, em um total de 52 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:

• Testando modelos clássicos
• Votação
• Bagging
• Boosting
• Stacking