In Depth_Naive Bayes Classification

Prévia do material em texto

23/06/2019 Em Profundidade: Classificação Naive Bayes | Manual da Python Data Science
https://jakevdp.github.io/PythonDataScienceHandbook/05.05-naive-bayes.html 1/10
Este é um extrato do Python Data Science Handbook, (http://shop.oreilly.com/product/0636920034919.do)
de Jake VanderPlas; Os notebooks Jupyter estão disponíveis no GitHub
(https://github.com/jakevdp/PythonDataScienceHandbook) .
O texto é liberado sob a licença CC-BY-NC-ND (https://creativecommons.org/licenses/by-nc-
nd/3.0/us/legalcode) , e o código é liberado sob a licença MIT (https://opensource.org/licenses/MIT) . Se você considera
este conteúdo útil, considere apoiar o trabalho comprando o livro (http://shop.oreilly.com/product/0636920034919.do) !
Em Profundidade: Naive Bayes
Classification
Open in ColabOpen in Colab
< Engenharia de recursos (05.04-feature-engineering.html) | Conteúdos (index.html) | Em
Profundidade: Regressão Linear (05.06-linear-regression.html) >
(https://colab.research.google.com/github/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/0
Naive-Bayes.ipynb)
As quatro seções anteriores deram uma visão geral dos conceitos de aprendizado de máquina.
Nesta seção e nos que se seguem, examinaremos mais de perto vários algoritmos específicos
para aprendizado supervisionado e não supervisionado, começando aqui com a classificação
ingênua de Bayes.
Os modelos Naive Bayes são um grupo de algoritmos de classificação extremamente rápidos e
simples que geralmente são adequados para conjuntos de dados de dimensões muito altas. Por
serem tão rápidos e ter tão poucos parâmetros ajustáveis, acabam sendo muito úteis como uma
linha de base rápida e suja para um problema de classificação. Esta seção se concentrará em
uma explicação intuitiva de como os classificadores bayes ingênuos funcionam, seguidos de
alguns exemplos deles em ação em alguns conjuntos de dados.
# Classificação Bayesiana 
Os classificadores Naive Bayes são construídos com métodos de classificação bayesianos. Estes
dependem do teorema de Bayes, que é uma equação que descreve a relação de probabilidades
condicionais de grandezas estatísticas. Na classificação Bayesiana, estamos interessados em
encontrar a probabilidade de um rótulo dado algumas características observadas, que podemos
escrever como . O teorema de Bayes nos diz como expressar
isso em termos de quantidades que podemos calcular mais diretamente:
( L | f  e um t u r e s )
P( L | f  e um t u r e s ) =
P( fum e uma t u r e s | L)P   ( L )
P( fe um t u r e s )
23/06/2019 Em Profundidade: Classificação Naive Bayes | Manual da Python Data Science
https://jakevdp.github.io/PythonDataScienceHandbook/05.05-naive-bayes.html 2/10
Se estamos tentando decidir entre dois rótulos - vamos chamá-los de e Então, uma
maneira de tomar essa decisão é calcular a razão das probabilidades posteriores de cada
etiqueta:
Tudo o que precisamos agora é algum modelo pelo qual possamos calcular 
para cada etiqueta. Esse modelo é chamado de modelo
generativo porque especifica o processo aleatório hipotético que gera os dados. Especificar esse
modelo generativo para cada rótulo é a parte principal do treinamento desse classificador
bayesiano. A versão geral de tal etapa de treinamento é uma tarefa muito difícil, mas podemos
simplificar o uso de algumas suposições simplificadoras sobre a forma desse modelo.
É aí que entra o ingênuo "ingênuo Bayes": se fizermos suposições muito ingênuas sobre o
modelo gerativo de cada rótulo, podemos encontrar uma aproximação aproximada do modelo
gerativo para cada classe e, então, prosseguir com a classificação bayesiana. . Diferentes tipos de
classificadores ingênuos de Bayes baseiam-se em diferentes suposições ingênuas sobre os
dados, e examinaremos alguns deles nas seções seguintes.
Nós começamos com as importações padrão:
Em 1]:
% Matplotlib linha 
 importar numpy como np 
importação matplotlib.pyplot como plt 
importação Seaborn como sns ; sns . set ()
# Gaussian Naive Bayes 
Talvez o mais simples classificador ingênuo de Bayes para entender seja o Bayes ingênuo de
Gauss. Nesse classificador, a suposição é que os dados de cada rótulo são extraídos de uma
distribuição Gaussiana simples . Imagine que você tenha os seguintes dados:
1 2
= 
P(  | f e um t u r e s )L
1
P(  | f e um t u r e s )L
2
P( fum e uma t u r e s |    )
1
P( fum e uma t u r e s |    )
2
P( )L
1
P( )L
2
( fum e uma t u r e s |    )
Eu
23/06/2019 Em Profundidade: Classificação Naive Bayes | Manual da Python Data Science
https://jakevdp.github.io/PythonDataScienceHandbook/05.05-naive-bayes.html 3/10
Em 2]:
Uma maneira extremamente rápida de criar um modelo simples é assumir que os dados são
descritos por uma distribuição gaussiana sem covariância entre as dimensões. Esse modelo
pode ser ajustado simplesmente encontrando a média e o desvio padrão dos pontos dentro de
cada etiqueta, o que é tudo o que você precisa para definir essa distribuição. O resultado dessa
suposição gaussiana ingênua é mostrado na figura a seguir:
figura fonte no apêndice (06.00-figure-code.html#Gaussian-Naive-Bayes)
de sklearn.datasets import make_blobs 
X , y = make_blobs ( 100 , 2 , centros = 2 , estado_aleatório = 2 , cluster_std = 1
plt . dispersão ( X [: 0 ], X [: 1 ], c = y , s = 50 , cmap = 'RdBu' );
23/06/2019 Em Profundidade: Classificação Naive Bayes | Manual da Python Data Science
https://jakevdp.github.io/PythonDataScienceHandbook/05.05-naive-bayes.html 4/10
As elipses aqui representam o modelo generativo gaussiano para cada rótulo, com maior
probabilidade em direção ao centro das elipses. Com este modelo generativo em vigor para cada
classe, temos uma receita simples para calcular a probabilidade 
 para qualquer ponto de dados, e assim podemos calcular
rapidamente a relação posterior e determinar qual rótulo é o mais provável para um dado ponto.
Este procedimento é implementado no estimador do Scikit-Learn
sklearn.naive_bayes.GaussianNB :
Em [3]:
de sklearn.naive_bayes importar GaussianNB 
modelo = GaussianNB () 
modelo . ajuste ( X , y );
Agora vamos gerar alguns dados novos e prever o rótulo:
Em [4]:
rng = np . aleatório . RandomState ( 0 ) 
Xnew = [ - 6 , - 14 ] + [ 14 , 18 ] * rng . rand ( 2000 , 2 ) 
ynew = modelo . prever ( Xnew )
Agora podemos plotar esses novos dados para ter uma ideia de onde está o limite de decisão:
Em [5]:
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='RdBu')
lim = plt.axis()
plt.scatter(Xnew[:, 0], Xnew[:, 1], c=ynew, s=20, cmap='RdBu', alpha=0.1)
plt.axis(lim);
We see a slightly curved boundary in the classifications—in general, the boundary in Gaussian
naive Bayes is quadratic.
( fum e uma t u r e s |    )
1
23/06/2019 Em Profundidade: Classificação Naive Bayes | Manual da Python Data Science
https://jakevdp.github.io/PythonDataScienceHandbook/05.05-naive-bayes.html 5/10
A nice piece of this Bayesian formalism is that it naturally allows for probabilistic classification,
which we can compute using the predict_proba method:
In [6]:
yprob = model.predict_proba(Xnew)
yprob[-8:].round(2)
The columns give the posterior probabilities of the first and second label, respectively. If you are
looking for estimates of uncertainty in your classification, Bayesian approaches like this can be a
useful approach.
Of course, the final classification will only be as good as the model assumptions that lead to it,
which is why Gaussian naive Bayes o�en does not produce very good results. Still, in many cases
—especially as the number of features becomes large—this assumption is not detrimental
enough to prevent Gaussian naive Bayes from being a useful method.
# Multinomial Naive Bayes
The Gaussian assumption just described is by no means the only simple assumption that could
beused to specify the generative distribution for each label. Another useful example is
multinomial naive Bayes, where the features are assumed to be generated from a simple
multinomial distribution. The multinomial distribution describes the probability of observing
counts among a number of categories, and thus multinomial naive Bayes is most appropriate for
features that represent counts or count rates.
The idea is precisely the same as before, except that instead of modeling the data distribution
with the best-fit Gaussian, we model the data distribuiton with a best-fit multinomial
distribution.
## Example: Classifying Text
One place where multinomial naive Bayes is o�en used is in text classification, where the
features are related to word counts or frequencies within the documents to be classified. We
discussed the extraction of such features from text in Feature Engineering (05.04-feature-
Out[6]:
array([[ 0.89, 0.11], 
 [ 1. , 0. ], 
 [ 1. , 0. ], 
 [ 1. , 0. ], 
 [ 1. , 0. ], 
 [ 1. , 0. ], 
 [ 0. , 1. ], 
 [ 0.15, 0.85]])
23/06/2019 Em Profundidade: Classificação Naive Bayes | Manual da Python Data Science
https://jakevdp.github.io/PythonDataScienceHandbook/05.05-naive-bayes.html 6/10
engineering.html); here we will use the sparse word count features from the 20 Newsgroups
corpus to show how we might classify these short documents into categories.
Let's download the data and take a look at the target names:
In [7]:
from sklearn.datasets import fetch_20newsgroups
data = fetch_20newsgroups()
data.target_names
For simplicity here, we will select just a few of these categories, and download the training and
testing set:
In [8]:
categories = ['talk.religion.misc', 'soc.religion.christian', 
 'sci.space', 'comp.graphics']
train = fetch_20newsgroups(subset='train', categories=categories)
test = fetch_20newsgroups(subset='test', categories=categories)
Here is a representative entry from the data:
Out[7]:
['alt.atheism', 
 'comp.graphics', 
 'comp.os.ms-windows.misc', 
 'comp.sys.ibm.pc.hardware', 
 'comp.sys.mac.hardware', 
 'comp.windows.x', 
 'misc.forsale', 
 'rec.autos', 
 'rec.motorcycles', 
 'rec.sport.baseball', 
 'rec.sport.hockey', 
 'sci.crypt', 
 'sci.electronics', 
 'sci.med', 
 'sci.space', 
 'soc.religion.christian', 
 'talk.politics.guns', 
 'talk.politics.mideast', 
 'talk.politics.misc', 
 'talk.religion.misc']
23/06/2019 Em Profundidade: Classificação Naive Bayes | Manual da Python Data Science
https://jakevdp.github.io/PythonDataScienceHandbook/05.05-naive-bayes.html 7/10
In [9]:
print(train.data[5])
In order to use this data for machine learning, we need to be able to convert the content of each
string into a vector of numbers. For this we will use the TF-IDF vectorizer (discussed in Feature
Engineering (05.04-feature-engineering.html)), and create a pipeline that attaches it to a
multinomial naive Bayes classifier:
In [10]:
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import make_pipeline
model = make_pipeline(TfidfVectorizer(), MultinomialNB())
With this pipeline, we can apply the model to the training data, and predict labels for the test
data:
In [11]:
model.fit(train.data, train.target)
labels = model.predict(test.data)
Now that we have predicted the labels for the test data, we can evaluate them to learn about the
performance of the estimator. For example, here is the confusion matrix between the true and
predicted labels for the test data:
From: dmcgee@uluhe.soest.hawaii.edu (Don McGee) 
Subject: Federal Hearing 
Originator: dmcgee@uluhe 
Organization: School of Ocean and Earth Science and Technology 
Distribution: usa 
Lines: 10
 
Fact or rumor....? Madalyn Murray O'Hare an atheist who eliminated the 
use of the bible reading and prayer in public schools 15 years ago is now 
going to appear before the FCC with a petition to stop the reading of the 
Gospel on the airways of America. And she is also campaigning to remove 
Christmas programs, songs, etc from the public schools. If it is true 
then mail to Federal Communications Commission 1919 H Street Washington DC 
20054 expressing your opposition to her request. Reference Petition number
 
2493.
23/06/2019 Em Profundidade: Classificação Naive Bayes | Manual da Python Data Science
https://jakevdp.github.io/PythonDataScienceHandbook/05.05-naive-bayes.html 8/10
In [12]:
from sklearn.metrics import confusion_matrix
mat = confusion_matrix(test.target, labels)
sns.heatmap(mat.T, square=True, annot=True, fmt='d', cbar=False, 
 xticklabels=train.target_names, yticklabels=train.target_names)
plt.xlabel('true label')
plt.ylabel('predicted label');
Evidently, even this very simple classifier can successfully separate space talk from computer
talk, but it gets confused between talk about religion and talk about Christianity. This is perhaps
an expected area of confusion!
The very cool thing here is that we now have the tools to determine the category for any string,
using the predict() method of this pipeline. Here's a quick utility function that will return the
prediction for a single string:
In [13]:
def predict_category(s, train=train, model=model): 
 pred = model.predict([s]) 
 return train.target_names[pred[0]]
Let's try it out:
In [14]:
predict_category('sending a payload to the ISS')
Out[14]:
'sci.space'
23/06/2019 Em Profundidade: Classificação Naive Bayes | Manual da Python Data Science
https://jakevdp.github.io/PythonDataScienceHandbook/05.05-naive-bayes.html 9/10
In [15]:
predict_category('discussing islam vs atheism')
In [16]:
predict_category ( 'determinando a resolução da tela' )
Lembre-se de que isso não é nada mais sofisticado do que um modelo de probabilidade simples
para a frequência (ponderada) de cada palavra na string; no entanto, o resultado é
impressionante. Mesmo um algoritmo muito ingênuo, quando usado com cuidado e treinado em
um grande conjunto de dados de alta dimensão, pode ser surpreendentemente eficaz.
# Quando usar Naive Bayes 
Como os classificadores bayesianos ingênuos fazem suposições rigorosas sobre os dados, eles
geralmente não têm um desempenho tão bom quanto um modelo mais complicado. Dito isto,
eles têm várias vantagens:
Eles são extremamente rápidos tanto para treino como para previsão
Eles fornecem previsão probabilística direta
Eles são muitas vezes facilmente interpretáveis
Eles têm muito poucos parâmetros sintonizáveis (se houver)
Essas vantagens significam que um classificador bayesiano ingênuo é muitas vezes uma boa
escolha como classificação inicial inicial. Se ele funcionar adequadamente, então parabéns: você
tem um classificador muito rápido e muito interpretável para o seu problema. Se não tiver um
bom desempenho, você poderá começar a explorar modelos mais sofisticados, com algum
conhecimento básico de como eles devem ser realizados.
Os classificadores Naive Bayes tendem a ter um desempenho especialmente bom em uma das
seguintes situações:
Quando as suposições ingênuas realmente correspondem aos dados (muito raros na
prática)
Para categorias muito bem separadas, quando a complexidade do modelo é menos
importante
Para dados de altíssima dimensão, quando a complexidade do modelo é menos
importante
Out[15]:
'soc.religion.christian'
Fora [16]:
'comp.graphics'
23/06/2019 Em Profundidade: Classificação Naive Bayes | Manual da Python Data Science
https://jakevdp.github.io/PythonDataScienceHandbook/05.05-naive-bayes.html 10/10
Os dois últimos pontos parecem distintos, mas na verdade estão relacionados: à medida que a
dimensão de um conjunto de dados cresce, é muito menos provável que quaisquer dois pontossejam encontrados próximos (afinal, eles devem estar próximos em todas as dimensões para
ficarem próximos) No geral). Isso significa que os clusters em altas dimensões tendem a ser mais
separados, em média, do que os clusters em dimensões baixas, assumindo que as novas
dimensões realmente adicionam informações. Por essa razão, classificadores simplistas como
Bayes ingênuos tendem a funcionar tão bem ou melhor que classificadores mais complicados à
medida que a dimensionalidade cresce: uma vez que você tenha dados suficientes, até mesmo
um modelo simples pode ser muito poderoso.
Open in ColabOpen in Colab
< Engenharia de recursos (05.04-feature-engineering.html) | Conteúdos (index.html) | Em
Profundidade: Regressão Linear (05.06-linear-regression.html) >
(https://colab.research.google.com/github/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/0
Naive-Bayes.ipynb)