Implemente um classifacor Naive Bayes para o problema de predizer a qualidade de um carro. Para este fim, utilizaremos um conjunto de dados referente a qualidade de carros, disponível no UCI. Este dataset de carros possui as seguintes features e classe:
Attributos
Classes
Crie uma versão de sua implementação usando as funções disponíveis na biblioteca SciKitLearn para o Naive Bayes (veja aqui)
Analise a acurácia dos dois algoritmos e discuta a sua solução.
In [9]:
# Libraries
import numpy as np
import pandas as pd
from sklearn.naive_bayes import MultinomialNB, GaussianNB
from sklearn.cross_validation import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score, classification_report
In [2]:
# Creating a class for the Naive Bayes
class NaiveBayes:
def __init__(self):
''' Default Constructor '''
self.lEncoder = LabelEncoder()
self.X = None; self.y = None
self.classProb = None; self.likeTable = {}
def separateByClass(self):
''' This functions separates all the dataset indexing dictionaries by the classes '''
separated = {}
for i in range(len(self.y)):
if (self.y[i] not in separated):
separated[self.y[i]] = []
separated[self.y[i]].append(self.X[i])
return separated
def makeLikeTable(self):
''' This functions counts the occurences of each attribute based on the classes
and construct the Likelihood table (in this case a Dictionary) calculating all
the propers probabilities '''
sepClass = self.separateByClass()
classSizes = [len(sepClass[i]) for i in sepClass.keys()]
self.classProb = np.array(classSizes) / sum(classSizes)
self.likeTable = {}
for label in sepClass.keys():
aux = np.column_stack(sepClass[label])
for attribute,idx in zip(aux, range(len(aux))):
counts = np.asarray(np.unique(attribute, return_counts=True)).T
for i in range(4):
self.likeTable[(label, idx, i)] = 0
for count_it in counts:
self.likeTable[(label, idx, count_it[0])] = count_it[1] / len(sepClass[label])
def calculateProbability(self, inputVector):
''' Utilizes the maximum likelihood estimation to calculate the probabilty of
each row in inputVector belongs to each possible class '''
sepClass = self.separateByClass()
probabilities = {}
for label,_ in sepClass.items():
probabilities[label] = self.classProb[label]
for i in range(len(inputVector)):
probabilities[label] *= self.likeTable[label, i, inputVector[i]]
return probabilities
def fit(self, X_train, y_train):
''' Assign the training data and calls the Likelihood Table creator '''
self.X = X_train
self.y = y_train
self.makeLikeTable()
def predict(self, inputArray):
''' Return a list of predictions for each row in inputArray correspondent to
the label of the class with the maximum probability '''
predictions = []
for row in inputArray:
probabilities = self.calculateProbability(row)
predictions.append(max(probabilities, key=probabilities.get))
return predictions
In [10]:
# Carregando o Dataset
data = pd.read_csv("car.data", header=None)
# Transformando as variáveis categóricas em valores discretos contáveis
# Apesar de diminuir a interpretação dos atributos, essa medida facilita bastante a vida dos métodos de contagem
for i in range(0, data.shape[1]):
data.iloc[:,i] = LabelEncoder().fit_transform(data.iloc[:,i])
# Separação do Conjunto de Treino e Conjunto de Teste (80%/20%)
X_train, X_test, y_train, y_test = train_test_split(data.iloc[:,:-1], data.iloc[:,-1], test_size=0.2)
In [11]:
# Implementação do Naive Bayes Multinomial do SKLearn
# O Naive Bayes Multinomial é a implementação do SKLearn que funciona para variáveis discretas,
# ao invés de utilizar o modelo da função gaussiana (a classe GaussianNB faz dessa forma)
clf = MultinomialNB()
clf.fit(X_train.values, y_train.values)
y_pred = clf.predict(X_test.values)
# Impressão dos Resultados
print("Multinomial Naive Bayes (SKlearn Version)")
print("Total Accuracy: {}%".format(accuracy_score(y_true=y_test, y_pred=y_pred)))
print("\nClassification Report:")
print(classification_report(y_true=y_test, y_pred=y_pred, target_names=["unacc", "acc", "good", "vgood"]))
In [12]:
# Utilização da minha função própria de Naive Bayes para o mesmo conjunto de dados
nBayes = NaiveBayes()
nBayes.fit(X_train.values, y_train.values)
y_pred = nBayes.predict(X_test.values)
# Impressão dos Resultados
print("Naive Bayes (My Version :D)")
print("Total Accuracy: {}%".format(accuracy_score(y_true=y_test, y_pred=y_pred)))
print("\nClassification Report:")
print(classification_report(y_true=y_test, y_pred=y_pred, target_names=["unacc", "acc", "good", "vgood"]))
Na minha implementação, assim como no SKLearn, existem duas funções principais: .fit() e .predict().
A função .fit() é responsável por receber os dados de Treino e, através deles, criar as tabelas de Likelihood para cada atributo. Essa tabela é criada através da função .makeLikeTable() que, basicamente, separa todos os exemplos por classe e, para cada classe, realiza a contagem de frequência de cada atributo e calcula as devidas probabilidades. A tabela Likelihood do meu classificador é indexado pela classe, índice do atributo e valor do atributo. Logo, ele possui as probabilidades:
$$ P(X_{i}=x\ |\ C_{j})$$onde $X_i$ é o atributo de índice $i$, $x$ é o valor que ele assume e $C_j$ é a classe de índice $j$.
A função .predict() é responsável por receber os diversos inputs (exemplos para serem classificados) e retornar o label da classe com maior probabilidade para tais inputs. Ele utiliza da função .calculateProbability() para calcular a probabilidade:
$$ P(C\ |\ X) = P(C) \prod_i P(X_{i}\ |\ C)) $$que é a probabilidade de maximum likelihood definida para a classe C, dado os atributos X. A resposta da predição é, então, a classe para qual o valor da probabilidade acima é máxima.
Podemos notar que o algoritmo possui um resultado relativamente satisfatório. Apesar de tomar certas suposições bem rígidas, alguns casos realmente caem sobre os casos contemplados pelo Naive Bayes, e a classificação se mostra proveitosa.
Todavia, é perceptível que esse algoritmo depende bastante da frequência relativa de cada class. Se olharmos na equação acima, podemos perceber que a probabilidade de maximum likelihood é proporcional à probabilidade marginal das classes. Por esse motivo, classes que possuem uma frequência muito maior que as outras terão uma probabilidade maior, e irão influenciar mais no resultado da probabilidade final. Por esse motivo, podemos ver que as classes com menos exemplares ("acc" e "vgood") acabam não tendo uma performance muito boa. Esse fato é ainda mais perceptível no Multinomial NaiveBayes, implementado pelo SKLearn. Por utilizar diferentes métodos de contagem, ele possui um melhor custo computacional, mas acaba subestimando as probabilidades das classes menos frequentes e, por consequência, vemos que as predições caem praticamente todas nas duas classes mais frequentes ("unacc" e "good")