Tutorial de classificação Naive Bayes usando o Scikit-learn

Fluxo de trabalho de classificação

Sempre que você realiza uma classificação, a primeira etapa é entender o problema e identificar possíveis recursos e rótulos. Os recursos são as características ou atributos que afetam os resultados do rótulo. Por exemplo, no caso da distribuição de um empréstimo, os gerentes do banco identificam a ocupação, a renda, a idade, a localização, o histórico de empréstimos anteriores, o histórico de transações e a pontuação de crédito do cliente. Essas características são conhecidas como recursos que ajudam o modelo a classificar os clientes.

A classificação tem duas fases: uma fase de aprendizado e a fase de avaliação. Na fase de aprendizado, o classificador treina seu modelo em um determinado conjunto de dados e, na fase de avaliação, ele testa o desempenho do classificador. O desempenho é avaliado com base em vários parâmetros, como exatidão, erro, precisão e recuperação.

O que é o classificador Naive Bayes?

Naive Bayes é uma técnica de classificação estatística baseada no Teorema de Bayes. É um dos algoritmos de aprendizado supervisionado mais simples. O classificador Naive Bayes é um algoritmo rápido, preciso e confiável. Os classificadores Naive Bayes têm alta precisão e velocidade em grandes conjuntos de dados.

O classificador Naive Bayes pressupõe que o efeito de um determinado recurso em uma classe é independente de outros recursos. Por exemplo, um candidato a empréstimo é desejável ou não dependendo de sua renda, histórico de empréstimos e transações anteriores, idade e localização. Mesmo que esses recursos sejam interdependentes, eles ainda são considerados de forma independente. Essa suposição simplifica a computação e, por isso, é considerada ingênua. Essa suposição é chamada de independência condicional de classe.

• P(h): a probabilidade de a hipótese h ser verdadeira (independentemente dos dados). Isso é conhecido como a probabilidade prévia de h.
• P(D): a probabilidade dos dados (independentemente da hipótese). Isso é conhecido como probabilidade prévia.
• P(h|D): a probabilidade da hipótese h com base nos dados D. Isso é conhecido como probabilidade posterior.
• P(D|h): a probabilidade dos dados d, se a hipótese h for verdadeira. Isso é conhecido como probabilidade posterior.

Como funciona o classificador Naive Bayes?

Vamos entender o funcionamento do Naive Bayes por meio de um exemplo. Dê um exemplo de condições climáticas e prática de esportes. Você precisa calcular a probabilidade de praticar esportes. Agora, você precisa classificar se os jogadores jogarão ou não, com base nas condições climáticas.

Primeira abordagem (no caso de um único recurso)

O classificador Naive Bayes calcula a probabilidade de um evento nas seguintes etapas:

• Etapa 1: Calcule a probabilidade prévia para determinados rótulos de classe
• Etapa 2: Encontre a probabilidade de Likelihood com cada atributo para cada classe
• Etapa 3: Coloque esses valores na fórmula de Bayes e calcule a probabilidade posterior.
• Etapa 4: Veja qual classe tem maior probabilidade, uma vez que a entrada pertence à classe de maior probabilidade.

Para simplificar o cálculo da probabilidade prévia e posterior, você pode usar as duas tabelas de frequência e de probabilidade. Essas duas tabelas ajudarão você a calcular a probabilidade prévia e posterior. A tabela de frequência contém a ocorrência de rótulos para todos os recursos. Há duas tabelas de probabilidade. A Tabela de probabilidade 1 mostra as probabilidades anteriores dos rótulos e a Tabela de probabilidade 2 mostra a probabilidade posterior.

Agora, suponha que você queira calcular a probabilidade de jogar quando o tempo estiver nublado.

Probabilidade de jogar:

P(Yes | Overcast) = P(Overcast | Yes) P(Yes) / P (Overcast) .....................(1)

1. Calcular probabilidades prévias:

   P(nublado) = 4/14 = 0,29

   P(Sim)= 9/14 = 0,64

1. Calcule as probabilidades posteriores:

   P(Nublado |Sim) = 4/9 = 0,44

1. Coloque as probabilidades anterior e posterior na equação (1)

   P (Sim | Nublado) = 0,44 * 0,64 / 0,29 = 0,98 (mais alto)

Da mesma forma, você pode calcular a probabilidade de não jogar:

Probabilidade de você não jogar:

P(No | Overcast) = P(Overcast | No) P(No) / P (Overcast) .....................(2)

1. Calcular probabilidades prévias:

   P(nublado) = 4/14 = 0,29

   P(Não)= 5/14 = 0,36

1. Calcule as probabilidades posteriores:

   P(Nublado |Não) = 0/9 = 0

1. Coloque as probabilidades anterior e posterior na equação (2)

   P (Não | Nublado) = 0 * 0,36 / 0,29 = 0

A probabilidade de uma classe "Sim" é maior. Portanto, você pode determinar aqui que, se o tempo estiver nublado, os jogadores praticarão o esporte.

Segunda abordagem (no caso de vários recursos)

Agora, suponha que você queira calcular a probabilidade de jogar quando o tempo estiver nublado e a temperatura for amena.

Probabilidade de jogar:

P(Play= Yes | Weather=Overcast, Temp=Mild) = P(Weather=Overcast, Temp=Mild | Play= Yes)P(Play=Yes) ..........(1)

P(Weather=Overcast, Temp=Mild | Play= Yes)= P(Overcast |Yes) P(Mild |Yes) ...........(2)

1. Calcular probabilidades prévias: P(Sim)= 9/14 = 0,64

2. Calcule as probabilidades posteriores: P(Nublado |Sim) = 4/9 = 0,44 P(Ameno |Sim) = 4/9 = 0,44

3. Coloque as probabilidades posteriores na equação (2) P(Weather=Overcast, Temp=Mild | Play= Yes) = 0,44 * 0,44 = 0,1936(Higher)

4. Coloque as probabilidades anterior e posterior na equação (1) P(Play= Yes | Weather=Overcast, Temp=Mild) = 0,1936*0,64 = 0,124

Da mesma forma, você pode calcular a probabilidade de não jogar:

Probabilidade de você não jogar:

P(Play= No | Weather=Overcast, Temp=Mild) = P(Weather=Overcast, Temp=Mild | Play= No)P(Play=No) ..........(3)

P(Weather=Overcast, Temp=Mild | Play= No)= P(Weather=Overcast |Play=No) P(Temp=Mild | Play=No) ...........(4)

1. Calcular probabilidades prévias: P(Não)= 5/14 = 0,36

2. Calcule as probabilidades posteriores: P(Weather=Overcast | Play=No) = 0/9 = 0 P(Temp=Mild | Play=No)=2/5=0,4

3. Coloque as probabilidades posteriores na equação (4) P(Weather=Overcast, Temp=Mild | Play= No) = 0 * 0,4= 0

4. Coloque as probabilidades anteriores e posteriores na equação (3) P(Play= No | Weather=Overcast, Temp=Mild) = 0*0.36=0

A probabilidade de uma classe "Sim" é maior. Portanto, você pode dizer que, se o tempo estiver nublado, os jogadores praticarão o esporte.

Criação de classificadores no Scikit-learn

Classificador Naive Bayes com conjunto de dados sintéticos

No primeiro exemplo, geraremos dados sintéticos usando o scikit-learn, treinaremos e avaliaremos o algoritmo Gaussian Naive Bayes. 

Geração do conjunto de dados

O Scikit-learn nos fornece um ecossistema de aprendizado de máquina para que você possa gerar o conjunto de dados e avaliar vários algoritmos de aprendizado de máquina. 

No nosso caso, estamos criando um conjunto de dados com seis recursos, três classes e 800 amostras usando a função `make_classification`. 

from sklearn.datasets import make_classification

X, y = make_classification(
    n_features=6,
    n_classes=3,
    n_samples=800,
    n_informative=2,
    random_state=1,
    n_clusters_per_class=1,
)

Usaremos a função `scatter` do matplotlib.pyplot para visualizar o conjunto de dados. 

import matplotlib.pyplot as plt

plt.scatter(X[:, 0], X[:, 1], c=y, marker="*");

Como podemos observar, há três tipos de rótulos de destino, e estaremos treinando um modelo de classificação multiclasse. 

Divisão de teste de trem

Antes de iniciarmos o processo de treinamento, precisamos dividir o conjunto de dados em treinamento e teste para avaliação do modelo. 

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.33, random_state=125
)

Construção de modelos e treinamento 

Crie um Naive Bayes gaussiano genérico e treine-o em um conjunto de dados de treinamento. Depois disso, alimente o modelo com uma amostra de teste aleatória para obter um valor previsto.

from sklearn.naive_bayes import GaussianNB

# Build a Gaussian Classifier
model = GaussianNB()

# Model training
model.fit(X_train, y_train)

# Predict Output
predicted = model.predict([X_test[6]])

print("Actual Value:", y_test[6])
print("Predicted Value:", predicted[0])

Os valores reais e previstos são os mesmos. 

Actual Value: 0
Predicted Value: 0

Avaliação do modelo

Não desenvolveremos o modelo em um conjunto de dados de teste não visto. Primeiro, vamos prever os valores para o conjunto de dados de teste e usá-los para calcular a precisão e a pontuação F1. 

from sklearn.metrics import (
    accuracy_score,
    confusion_matrix,
    ConfusionMatrixDisplay,
    f1_score,
)

y_pred = model.predict(X_test)
accuray = accuracy_score(y_pred, y_test)
f1 = f1_score(y_pred, y_test, average="weighted")

print("Accuracy:", accuray)
print("F1 Score:", f1)

Nosso modelo teve um desempenho razoavelmente bom com os hiperparâmetros padrão. 

Accuracy: 0.8484848484848485
F1 Score: 0.8491119695890328

Para visualizar a matriz de confusão, usaremos `confusion_matrix` para calcular os verdadeiros positivos e os verdadeiros negativos e `ConfusionMatrixDisplay` para exibir a matriz de confusão com os rótulos.

labels = [0,1,2]
cm = confusion_matrix(y_test, y_pred, labels=labels)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=labels)
disp.plot();

Nosso modelo teve um desempenho muito bom, e podemos melhorar o desempenho do modelo por meio de dimensionamento, pré-processamento de validação cruzada e otimização de hiperparâmetros. 

Classificador Naive Bayes com conjunto de dados de empréstimos

Vamos treinar o classificador Naive Bayes no conjunto de dados real. Repetiremos a maioria das tarefas, exceto o pré-processamento e a exploração de dados. 

Carregamento de dados

Neste exemplo, carregaremos dados de empréstimo do DataLab usando a função "read_csv" do pandas. 

import pandas as pd


df = pd.read_csv('loan_data.csv')
df.head()

Exploração de dados

Para saber mais sobre o conjunto de dados, usaremos `.info()`.

• O conjunto de dados consiste em 14 colunas e 9578 linhas.
• Além da "finalidade", as colunas são flutuantes ou inteiras. 
• Nossa coluna de destino é "not.fully.paid". 

df.info()

RangeIndex: 9578 entries, 0 to 9577
Data columns (total 14 columns):
#   Column             Non-Null Count  Dtype 
---  ------             --------------  ----- 
0   credit.policy      9578 non-null   int64 
1   purpose            9578 non-null   object
2   int.rate           9578 non-null   float64
3   installment        9578 non-null   float64
4   log.annual.inc     9578 non-null   float64
5   dti                9578 non-null   float64
6   fico               9578 non-null   int64 
7   days.with.cr.line  9578 non-null   float64
8   revol.bal          9578 non-null   int64 
9   revol.util         9578 non-null   float64
10  inq.last.6mths     9578 non-null   int64 
11  delinq.2yrs        9578 non-null   int64 
12  pub.rec            9578 non-null   int64 
13  not.fully.paid     9578 non-null   int64 
dtypes: float64(6), int64(7), object(1)
memory usage: 1.0+ MB

Neste exemplo, estaremos desenvolvendo um modelo para prever os clientes que não pagaram totalmente o empréstimo. Vamos explorar a finalidade e a coluna de destino usando o countplot do seaborn. 

import seaborn as sns
import matplotlib.pyplot as plt

sns.countplot(data=df,x='purpose',hue='not.fully.paid')
plt.xticks(rotation=45, ha='right');

Nosso conjunto de dados é um desequilíbrio que afetará o desempenho do modelo. Você pode conferir o tutorial Resample an Imbalanced Dataset para obter experiência prática no manuseio de conjuntos de dados desequilibrados.

Processamento de dados 

Agora, converteremos a coluna "purpose" de categórica para inteira usando a função `get_dummies` do pandas.

pre_df = pd.get_dummies(df,columns=['purpose'],drop_first=True)
pre_df.head()

Depois disso, definiremos as variáveis de recurso (X) e de destino (y) e dividiremos o conjunto de dados em conjuntos de treinamento e de teste. 

from sklearn.model_selection import train_test_split

X = pre_df.drop('not.fully.paid', axis=1)
y = pre_df['not.fully.paid']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.33, random_state=125
)

Construção de modelos e treinamento

A criação de modelos e o treinamento são bastante simples. Treinaremos um modelo em um conjunto de dados de treinamento usando hiperparâmetros padrão. 

from sklearn.naive_bayes import GaussianNB

model = GaussianNB()

model.fit(X_train, y_train);

Avaliação do modelo

Usaremos a precisão e a pontuação f1 para determinar o desempenho do modelo, e parece que o algoritmo Gaussian Naive Bayes teve um desempenho muito bom. 

from sklearn.metrics import (
    accuracy_score,
    confusion_matrix,
    ConfusionMatrixDisplay,
    f1_score,
    classification_report,
)

y_pred = model.predict(X_test)

accuray = accuracy_score(y_pred, y_test)
f1 = f1_score(y_pred, y_test, average="weighted")

print("Accuracy:", accuray)
print("F1 Score:", f1)

Accuracy: 0.8206263840556786
F1 Score: 0.8686606980013266

Devido à natureza desequilibrada dos dados, podemos ver que a matriz de confusão conta uma história diferente. Em um alvo minoritário: "não totalmente pago", temos mais rótulos errados. 

labels = ["Fully Paid", "Not fully Paid"]
cm = confusion_matrix(y_test, y_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=labels)
disp.plot();

Se estiver enfrentando problemas durante o treinamento ou a avaliação do modelo, você pode consultar o Naive Bayes Classification Tutorial usando a pasta de trabalho Scikit-learn DataLab. Ele vem com um conjunto de dados, código-fonte e resultados. 

Problema de probabilidade zero

Suponha que não haja nenhuma tupla para um empréstimo de risco no conjunto de dados; nesse cenário, a probabilidade posterior será zero, e o modelo não poderá fazer uma previsão. Esse problema é conhecido como probabilidade zero porque a ocorrência de uma determinada classe é zero.

A solução para esse problema é a correção Laplaciana ou a Transformação de Laplace. A correção laplaciana é uma das técnicas de suavização. Aqui, você pode presumir que o conjunto de dados é grande o suficiente para que a adição de uma linha de cada classe não faça diferença na probabilidade estimada. Isso resolverá o problema dos valores de probabilidade para zero.

Por exemplo: Suponha que, para a classe empréstimo arriscado, existam 1.000 tuplas de treinamento no banco de dados. Nesse banco de dados, a coluna de renda tem 0 tuplas para renda baixa, 990 tuplas para renda média e 10 tuplas para renda alta. As probabilidades desses eventos, sem a correção Laplaciana, são 0, 0,990 (de 990/1000) e 0,010 (de 10/1000)

Agora, aplique a correção Laplaciana no conjunto de dados fornecido. Vamos adicionar mais uma tupla para cada par de valores de renda. As probabilidades desses eventos:

Vantagens

• Não se trata apenas de uma abordagem simples, mas também de um método rápido e preciso de previsão.
• O Naive Bayes tem um custo de computação muito baixo.
• Ele pode trabalhar com eficiência em um grande conjunto de dados.
• Ele tem um bom desempenho no caso de uma variável de resposta discreta em comparação com a variável contínua.
• Ele pode ser usado com problemas de previsão de várias classes.
• Ele também tem um bom desempenho no caso de problemas de análise de texto.
• Quando a suposição de independência é mantida, o classificador Naive Bayes tem um desempenho melhor em comparação com outros modelos, como a regressão logística.

Desvantagens

• A suposição de recursos independentes. Na prática, é quase impossível que o modelo obtenha um conjunto de preditores que sejam totalmente independentes.
• Se não houver nenhuma tupla de treinamento de uma determinada classe, a probabilidade posterior será zero. Nesse caso, o modelo não é capaz de fazer previsões. Esse problema é conhecido como problema de probabilidade zero/frequência.

Conclusão

Parabéns, você chegou ao final deste tutorial!

Neste tutorial, você aprendeu sobre o algoritmo Naïve Bayes, seu funcionamento, a suposição do Naive Bayes, problemas, implementação, vantagens e desvantagens. Ao longo do caminho, você também aprendeu a criar e avaliar modelos no scikit-learn para classes binárias e multinomiais.

O Naive Bayes é o algoritmo mais simples e potente. Apesar dos avanços significativos no aprendizado de máquina nos últimos dois anos, ele provou seu valor. Ele foi implantado com sucesso em muitos aplicativos, desde a análise de texto até os mecanismos de recomendação.

Se você quiser saber mais sobre o scikit-learn em Python, faça nosso curso Aprendizado supervisionado com scikit-learn e confira nosso tutorial Scikit-Learn: Análise de beisebol Pt 1.