Machine Learning 101 — Clasificador Naive Bayes

El algoritmo de Naive Bayes es uno de los algoritmos de clasificación más utilizados en el Machine Learning. Se basa en la teoría de probabilidad y es utilizado para predecir la probabilidad de que un evento ocurra en función de la probabilidad de que ocurran otros eventos relacionados. En este artículo, vamos a profundizar en cómo funciona el algoritmo de Naive Bayes y su uso en Machine Learning

¿Cómo funciona el algoritmo de Naive Bayes?

El algoritmo de Naive Bayes se basa en el teorema de Bayes, que establece que la probabilidad de un evento dado un conjunto de condiciones puede ser calculada utilizando la probabilidad condicional inversa. En otras palabras, si conocemos la probabilidad de que ocurra un evento dado un conjunto de condiciones, podemos calcular la probabilidad de que ocurra otro evento relacionado.

Teorema de Bayes

En nuestro caso particular a implementar

El algoritmo de Naive Bayes es “ingenuo” en el sentido de que asume que todas las variables son independientes entre sí. Esto significa que no tiene en cuenta las relaciones entre las variables y las trata como si fueran independientes. A pesar de esta suposición simplista, el algoritmo de Naive Bayes sigue siendo muy preciso en la mayoría de los casos.

Lo que nosotros tenemos que encontrar en nuestro caso es el valor de “y” que nos permita maximizar la probabilidad.

Como solo nos interesa y, podemos solamente pensar en maximizar el término superior por lo que podríamos trabajar con:

Ahora bien, como todos estos argumentos dan valores entre 0 y 1 podemos encontrarnos con que el resultado se un número muy pequeño y genere problemas de overflow en nuestra ejecución, para prevenir esto podemos aplicar el logaritmo base 10 en cada uno de los términos lo cual va a reducir el tamaño de este resultado ya que podemos modificar el producto por una suma

Finalmente sabemos que P(y) será la frecuencia.

P(x_i|y) se puede calcular de la siguiente manera

Que es la formula de la distribución de Gauss donde:

• y es la variable aleatoria
• μ es la media (valor esperado) de la distribución
• σ es la desviación estándar de la distribución

Implementar el clasificador en Python

A continuación les comparto como implementar el clasificador en Python

import numpy as np

class NaiveBayes:

    def fit(self, X, y):
        # X es un numpy nd array con la cantidad de filas es el número de muestras y las columnas son el número de features
        n_samples, n_features = X.shape
        self._classes = np.unique(y)
        n_classes = len(self._classes)

        # init mean, var, priors
        self._mean = np.zeros((n_classes, n_features), dtype=np.float64)
        self._var = np.zeros((n_classes, n_features), dtype=np.float64)
        self.priors = np.zeros(n_classes, dtype=np.float64)

        for c in self._classes:
            X_c = X[c == y]
            self._mean[c, :] = X_c.mean(axis=0)
            self._var[c, :] = X_c.var(axis=0)
            # Nùmero de muestras con esta etiqueta dividido por el numero total de muestras, que tan seguido ocurre c
            self.priors[c] = X_c.shape[0] / float(n_samples)

    def predict(self, X):
        y_pred = [self._predict(x) for x in X]
        return y_pred

    def _predict(self, x):
        # Debo obtener el maximo de la probabilidad de cada uno de los elementos
        posteriors = []

        for idx, c in enumerate(self._classes):
            prior = np.log(self.priors[idx])
            class_conditional = np.sum(
                np.log(self._probabilityDensity(idx, x)))
            posterior = prior + class_conditional
            posteriors.append(posterior)

        # Con todos las probabiidades posteriores calculadas obtenemos la clase con mayot probabilidad usando el argmax de numpy
        return self._classes[np.argmax(posteriors)]

    # Realizo la formula de la densidad de probabilidad con la distribución de Gauss
    def _probabilityDensity(self, class_idx, x):
        mean = self._mean[class_idx]
        var = self._var[class_idx]
        numerator = np.exp(- (x - mean) ** 2 / (2 * var))
        denominator = np.sqrt(2 * np.pi * var)
        return numerator / denominator

Y sumamos una clase para poder testear nuestro clasificador

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn import datasets
import matplotlib.pyplot as plt

from nb import NaiveBayes


def accuracy(y_true, y_pred):
    accuracy = np.sum(y_true == y_pred) / len(y_true)
    return accuracy


X, y = datasets.make_classification(n_samples=1000,
                                    n_features=10, n_classes=2, random_state=123)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=123)

nb = NaiveBayes()
nb.fit(X_train, y_train)
predictions = nb.predict(X_test)

print("Presición de la clasificación con Naive Bayes", accuracy(y_test, predictions))

El algoritmo de Naive Bayes es uno de los algoritmos de clasificación más populares en el Machine Learning debido a su simplicidad y precisión. A pesar de su suposición simplista de independencia entre variables, el algoritmo sigue siendo muy útil en una amplia gama de aplicaciones.

Podes ver este código y el de los otros artículos en este repositorio.