Aplicación de Naive Bayes multinomial a problemas de PNL

El algoritmo clasificador bayesiano ingenuo es una familia de algoritmos probabilísticos basados ​​en la aplicación del teorema de Bayes con la suposición «ingenua» de independencia condicional entre cada par de características. 
El teorema de Bayes calcula la probabilidad P(c|x) donde c es la clase de los resultados posibles yx es la instancia dada que debe clasificarse, representando algunas características determinadas.
P(c|x) = P(x|c) * P(c) / P(x)
Naive Bayes se usa principalmente en problemas de procesamiento de lenguaje natural (NLP). Naive Bayes predice la etiqueta de un texto. Calculan la probabilidad de cada etiqueta para un texto dado y luego generan la etiqueta con la más alta. 
¿Cómo funciona el algoritmo Naive Bayes?
Consideremos un ejemplo, clasifiquemos la revisión si es positiva o negativa.
Conjunto de datos de entrenamiento:
 

Clasificamos si el texto «me gustó la película en general» tiene una crítica positiva o negativa. Tenemos que calcular, 
P (positivo | me gustó la película en general) , la probabilidad de que la etiqueta de una oración sea positiva dado que la oración es «me gustó la película en general». 
P(negativo | me gustó la película en general) : la probabilidad de que la etiqueta de una oración sea negativa dado que la oración es «me gustó la película en general».
Antes de eso, primero, aplicamos Remover palabras vacías y Stemming en el texto.
Eliminación de palabras vacías : estas son palabras comunes que realmente no agregan nada a la clasificación, como un capaz, tampoco, más, nunca, etc.
Stemming : Stemming para sacar la raíz de la palabra.
Ahora bien, después de aplicar estas dos técnicas, nuestro texto se convierte en
 

Ingeniería de características: 
la parte importante es encontrar las características de los datos para hacer que los algoritmos de aprendizaje automático funcionen. En este caso, tenemos texto. Necesitamos convertir este texto en números sobre los que podamos hacer cálculos. Usamos frecuencias de palabras. Eso es tratar cada documento como un conjunto de palabras que contiene. Nuestras características serán las cuentas de cada una de estas palabras.
En nuestro caso, tenemos P(positivo | en general me gustó la película) , usando este teorema:
 

P(positivo | en general le gustó la película) = P(en general le gustó la película | positivo) * P(positivo) / P(en general le gustó la película)

 
Dado que para nuestro clasificador tenemos que averiguar qué etiqueta tiene una mayor probabilidad, podemos descartar el divisor que es el mismo para ambas etiquetas,
P(me gustó la película en general | positivo)* P(positivo) con P(me gustó la película en general | negativo) * P(negativo)
Sin embargo, hay un problema: «en general le gustó la película» no aparece en nuestro conjunto de datos de entrenamiento, por lo que la probabilidad es cero. Aquí, asumimos la condición ‘ingenua’ de que cada palabra en una oración es independiente de las demás. Esto significa que ahora nos fijamos en las palabras individuales.
Podemos escribir esto como: 
 

P(en general le gustó la película) = P(en general) * P(me gustó) * P(la) * P(película)

El siguiente paso es simplemente aplicar el teorema de Bayes: – 
 

P(en general le gustó la película| positivo) = P(en general | positivo) * P(me gustó | positivo) * P(el | positivo) * P(película | positivo)

Y ahora, estas palabras individuales aparecen varias veces en nuestros datos de entrenamiento, ¡y podemos calcularlas!
Cálculo de probabilidades: 
Primero, calculamos la probabilidad a priori de cada etiqueta: para una oración dada en nuestros datos de entrenamiento, la probabilidad de que sea positiva P(positiva) es 3/5. Entonces, P(negativo) es 2/5.
Entonces, calcular P(en general | positivo) significa contar cuántas veces aparece la palabra “en general” en textos positivos (1) dividido por el número total de palabras en positivo (11). Por lo tanto, P(general | positivo) = 1/17, P(me gusta/positivo) = 1/17, P(el/positivo) = 2/17, P(película/positivo) = 3/17. 
Si la probabilidad resulta ser cero, entonces Usando el suavizado de Laplace: sumamos 1 a cada conteo para que nunca sea cero. Para equilibrar esto, sumamos el número de palabras posibles al divisor, por lo que la división nunca será mayor que 1. En nuestro caso, el número total de palabras posibles es 21.
Aplicando suavizado, los resultados son:
 

Ahora simplemente multiplicamos todas las probabilidades y vemos quién es más grande:
 

P(general | positivo) * P(me gusta | positivo) * P(el | positivo) * P(película | positivo) * P(positivo) = 1.38 * 10^{-5} = 0.0000138
P(general | negativo) * P(me gustó | negativo) * P(el | negativo) * P(película | negativo) * P(negativo) = 0.13 * 10^{-5} = 0.0000013

 
Nuestro clasificador le da a «me gustó la película en general» la etiqueta positiva.
A continuación se muestra la implementación: 
 

# cleaning texts
import pandas as pd
import re
import nltk
from nltk.corpus import stopwords
from nltk.stem.porter import PorterStemmer
from sklearn.feature_extraction.text import CountVectorizer
 
dataset = [["I liked the movie", "positive"],
           ["It’s a good movie. Nice story", "positive"],
           ["Hero’s acting is bad but heroine looks good.\
            Overall nice movie", "positive"],
            ["Nice songs. But sadly boring ending.", "negative"],
            ["sad movie, boring movie", "negative"]]
             
dataset = pd.DataFrame(dataset)
dataset.columns = ["Text", "Reviews"]
 
nltk.download('stopwords')
 
corpus = []
 
for i in range(0, 5):
    text = re.sub('[^a-zA-Z]', '', dataset['Text'][i])
    text = text.lower()
    text = text.split()
    ps = PorterStemmer()
    text = ''.join(text)
    corpus.append(text)
 
# creating bag of words model
cv = CountVectorizer(max_features = 1500)
 
X = cv.fit_transform(corpus).toarray()
y = dataset.iloc[:, 1].values

# splitting the data set into training set and test set
from sklearn.cross_validation import train_test_split
 
X_train, X_test, y_train, y_test = train_test_split(
           X, y, test_size = 0.25, random_state = 0)

# fitting naive bayes to the training set
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import confusion_matrix
 
classifier = GaussianNB();
classifier.fit(X_train, y_train)
 
# predicting test set results
y_pred = classifier.predict(X_test)
 
# making the confusion matrix
cm = confusion_matrix(y_test, y_pred)
cm