Ejemplo de cómo funciona el truco log-sum-exp en Naive Bayes

He leído sobre el truco log-sum-exp en muchos lugares (por ejemplo , aquí y aquí ) pero nunca he visto un ejemplo de cómo se aplica específicamente al clasificador Naive Bayes (por ejemplo, con características discretas y dos clases)

¿Cómo se evitaría exactamente el problema del desbordamiento numérico con este truco?

naive-bayes underflow Josh
fuente

Hay varios ejemplos de su uso aquí, aunque no necesariamente explícitamente para ingenuos Bayes. Sin embargo, eso apenas importa, ya que la idea del truco es bastante sencilla y fácilmente adaptable.

Glen_b -Reinstate Monica

Es más probable que el problema sea un desbordamiento que un desborde.

Henry

Le sugiero que intente una búsqueda en underflow y luego actualice su pregunta para abordar más específicamente lo que aún no está cubierto.

Glen_b -Reinstate Monica

¿Podría aclarar también: se trata de Bayes ingenuo modelo Bernoulli? algo más tal vez?

Glen_b -Reinstala a Monica el

Vea el ejemplo aquí , justo en la parte inferior (justo antes de 'Ver también' donde toman registros; exponiendo ambos lados pero dejando el RHS "tal cual" (como la exp de una suma de registros) sería un ejemplo del registro -sum-exp trick. ¿Te da suficiente información sobre su uso en Naive Bayes para hacer una pregunta más específica?

Glen_b -Reinstala Monica el

Respuestas:

p (Y = C | x) = \frac{p (x | Y = C) p (Y = C)}{\sum_{k = 1}^{| C |} p (x | Y = C_{k}) p (Y = C_{k})}

$p(Y=C|\mathbf{x}) = \frac{p(\mathbf{x}|Y=C)p(Y=C)}{~\sum_{k=1}^{|C|}{}p(\mathbf{x}|Y=C_k)p(Y=C_k)}$

tanto el denominador como el numerador pueden volverse muy pequeños, típicamente porque la puede estar cerca de 0 y multiplicamos muchos de ellos entre sí. Para evitar desbordamientos, uno simplemente puede tomar el registro del numerador, pero necesita usar el truco log-sum-exp para el denominador. $p(x_i \vert C_k)$

Más específicamente, para evitar desbordamientos:

Si solo nos interesa saber a qué clase la entrada probablemente pertenece con la regla de decisión de máximo a posteriori (MAP), no tenemos que aplicar el truco log-sum-exp, ya que no tenemos que calcular el denominador en ese caso. Para el numerador, uno simplemente puede tomar el registro para evitar desbordamientos: . Más específicamente: $(\hat{y})$ $(\mathbf{x}=x_1, \dots, x_n)$ $log \left( p(\mathbf{x}|Y=C)p(Y=C) \right)$

$\hat{y} = \underset{k \in {1, \dots, | C |}}{argmax} p (C_{k} | x_{1}, \dots, x_{n}) = \underset{k \in {1, \dots, | C |}}{argmax} p (C_{k}) \prod_{i = 1}^{n} p (x_{i} | C_{k})$ $\hat{y} = \underset{k \in \{1, \dots, |C|\}}{\operatorname{argmax}}p(C_k \vert x_1, \dots, x_n) = \underset{k \in \{1, \dots, |C|\}}{\operatorname{argmax}} \ p(C_k) \displaystyle\prod_{i=1}^n p(x_i \vert C_k)$
que se convierte después de tomar el registro:

\begin{aligned} \hat{y} & = \underset{k \in {1, \dots, | C |}}{argmax} \log (p (C_{k} | x_{1}, \dots, x_{n})) \\ = \underset{k \in {1, \dots, | C |}}{argmax} \log (p (C_{k}) \prod_{i = 1}^{n} p (x_{i} | C_{k})) \\ = \underset{k \in {1, \dots, | C |}}{argmax} (\log (p (C_{k})) + \sum_{i = 1}^{n} \log (p (x_{i} | C_{k}))) \end{aligned}

$\begin{align} \hat{y} &= \underset{k \in \{1, \dots, |C|\}}{\operatorname{argmax}} \log \left( p(C_k \vert x_1, \dots, x_n) \right)\\ &= \underset{k \in \{1, \dots, |C|\}}{\operatorname{argmax}} \log \left( \ p(C_k) \displaystyle\prod_{i=1}^n p(x_i \vert C_k) \right) \\ &= \underset{k \in \{1, \dots, |C|\}}{\operatorname{argmax}} \left( \log \left( p(C_k) \right) + \ \displaystyle\sum_{i=1}^n \log \left(p(x_i \vert C_k) \right) \right) \end{align}$

Si queremos calcular la probabilidad de clase , necesitaremos calcular el denominador: $p(Y=C|\mathbf{x})$

$\begin{aligned} \log (p (Y = C | x)) & = \log (\frac{p (x | Y = C) p (Y = C)}{\sum_{k = 1}^{| C |} p (x | Y = C_{k}) p (Y = C_{k})}) \\ = \log (\underset{numerator}{\underset{⏟}{p (x | Y = C) p (Y = C)}}) - \log (\underset{denominator}{\underset{⏟}{\sum_{k = 1}^{| C |} p (x | Y = C_{k}) p (Y = C_{k})}}) \end{aligned}$

El elemento puede desbordarse porque puede ser muy pequeño: es el mismo problema que en el numerador, pero esta vez tenemos una suma dentro del logaritmo, que nos impide transformar el (puede estar cerca de 0) en (negativo y ya no está cerca de 0, ya que ). Para evitar este problema, podemos utilizar el hecho de que para obtener: $\log \left( ~\sum_{k=1}^{|C|}{}p(\mathbf{x}|Y=C_k)p(Y=C_k) \right)\\$ $p(x_i \vert C_k)$ $p(x_i \vert C_k)$ $\log \left(p(x_i \vert C_k) \right)$ $0 \leq p(x_i \vert C_k) \leq 1$ $p(x_i \vert C_k) = \exp \left( {\log \left(p(x_i \vert C_k) \right)} \right)$

$\log (\sum_{k = 1}^{| C |} p (x | Y = C_{k}) p (Y = C_{k})) = \log (\sum_{k = 1}^{| C |} \exp (\log (p (x | Y = C_{k}) p (Y = C_{k}))))$

En ese punto, surge un nuevo problema: puede ser bastante negativo, lo que implica que puede llegar a estar muy cerca de 0, es decir, bajo flujo. Aquí es donde usamos el truco log-sum-exp : $\log \left( p(\mathbf{x}|Y=C_k)p(Y=C_k) \right)$ $\exp \left( \log \left( p(\mathbf{x}|Y=C_k)p(Y=C_k) \right) \right)$

$\log \sum_{k} e^{a_{k}} = \log \sum_{k} e^{a_{k}} e^{A - A} = A + \log \sum_{k} e^{a_{k} - A}$

con:
- $a_k=\log \left( p(\mathbf{x}|Y=C_k)p(Y=C_k) \right)$ ,
- $A = \underset{k \in \{1, \dots, |C|\}} \max a_k.$
Podemos ver que la introducción de la variable evita los desbordamientos. Por ejemplo, con , tenemos: $A$ $k=2, a_1 = - 245, a_2 = - 255$
- $\exp \left(a_1\right) = \exp \left(- 245\right) =3.96143\times 10^{- 107}$
- $\exp \left(a_2\right) = \exp \left(- 255\right) =1.798486 \times 10^{-111}$
Al usar el truco log-sum-exp evitamos el inferior, con : $A=\max ( -245, -255 )=-245$ $\begin{align}\log \sum_k e^{a_k} &= \log \sum_k e^{a_k}e^{A-A} \\&= A+ \log\sum_k e^{a_k -A}\\ &= -245+ \log\sum_k e^{a_k +245}\\&= -245+ \log \left(e^{-245 +245}+e^{-255 +245}\right) \\&=-245+ \log \left(e^{0}+e^{-10}\right) \end{align}$

Evitamos el desbordamiento ya que está mucho más lejos de 0 que o . $e^{-10}$ $3.96143\times 10^{- 107}$ $1.798486 \times 10^{-111}$

Franck Dernoncourt
fuente

Supongamos que queremos identificar cuál de las dos bases de datos es más probable que haya generado una frase (por ejemplo, de qué novela es más probable que haya surgido esta frase). Podríamos asumir la independencia de las palabras condicionales en la base de datos (supuesto de Naive Bayes).

Ahora busque el segundo enlace que ha publicado. Allí representaría la probabilidad conjunta de observar la oración dada una base de datos y los s representarían la probabilidad de observar cada una de las palabras en la oración. $a$ $e^{b_{t}}$

Sid
fuente

Podemos ver en esta respuesta que el número más pequeño en Python (solo tómalo , por ejemplo) se 5e-324debe al IEEE754 , y la causa del hardware también se aplica a otros idiomas.

In [2]: np.nextafter(0, 1)
Out[2]: 5e-324

Y cualquier flotador más pequeño que eso llevaría a 0.

In [3]: np.nextafter(0, 1)/2
Out[3]: 0.0

Y veamos la función de Naive Bayes with discrete features and two classescomo lo requirió:

p (S = 1 | w_{1}, . . . w_{n}) = \frac{p (S = 1) \prod_{i = 1}^{n} p (w_{i} | S = 1)}{\sum_{s = {0, 1}} p (S = s) \prod_{i = 1}^{n} p (w_{i} | S = s)}

$p(S=1|w_1, ... w_n) = \frac{p(S=1) \prod_{i=1}^n p(\mathbf{w_i}|S=1)}{~\sum_{s=\{0, 1\}}p(S=s)\prod_{i=1}^n p(\mathbf{w_i}|S=s)}$

Permítanme crear una instancia de esa función con una simple tarea de PNL a continuación.

Decidimos detectar si el correo electrónico entrante es spam ( ) o no spam ( ) y tenemos un vocabulario de 5.000 palabras ( ) y la única preocupación es si aparece una palabra ( ) ( ) en el correo electrónico o no ( ) por simplicidad ( Bernoulli ingenuo Bayes ). $S=1$ $S=0$ $n=5,000$ $w_i$ $p(w_i|S=1)$ $1-p(w_i|S=1)$

In [1]: import numpy as np
In [2]: from sklearn.naive_bayes import BernoulliNB
# let's train our model with 200 samples
In [3]: X = np.random.randint(2, size=(200, 5000))
In [4]: y = np.random.randint(2, size=(200, 1)).ravel()
In [5]: clf = BernoulliNB()
In [6]: model = clf.fit(X, y)

Podemos ver que sería muy pequeño debido a las probabilidades (tanto como estaría entre 0 y 1) en , y por lo tanto, estamos seguros de que el producto será menor que y solo obtenemos . $p(S=s)\prod_{i=1}^n p(\mathbf{w_i}|S=s)$ $p(w_i|S=1)$ $1-p(w_i|S=1)$ $\prod_i^{5000}$ $5e^{-324}$ $0/0$

In [7]: (np.nextafter(0, 1)*2) / (np.nextafter(0, 1)*2)
Out[7]: 1.0

In [8]: (np.nextafter(0, 1)/2) / (np.nextafter(0, 1)/2)
/home/lerner/anaconda3/bin/ipython3:1: RuntimeWarning: invalid value encountered in double_scalars
  #!/home/lerner/anaconda3/bin/python
Out[8]: nan
In [9]: l_cpt = model.feature_log_prob_
In [10]: x = np.random.randint(2, size=(1, 5000))
In [11]: cls_lp = model.class_log_prior_
In [12]: probs = np.where(x, np.exp(l_cpt[1]), 1-np.exp(l_cpt[1]))
In [13]: np.exp(cls_lp[1]) * np.prod(probs)
Out[14]: 0.0

Entonces surge el problema: ¿cómo podemos calcular la probabilidad de que el correo electrónico sea un spam ? ¿O cómo podemos calcular el numerador y el denominador? $p(S=1|w_1, ... w_n)$

Podemos ver la implementación oficial en sklearn :

jll = self._joint_log_likelihood(X)
# normalize by P(x) = P(f_1, ..., f_n)
log_prob_x = logsumexp(jll, axis=1)
return jll - np.atleast_2d(log_prob_x).T

Para el numerador, convirtió el producto de probabilidades en la suma de la probabilidad logarítmica y para el denominador usó logsumexp en scipy, que es:

out = log(sum(exp(a - a_max), axis=0))
out += a_max

Debido a que no podemos agregar dos probabilidades conjuntas agregando su probabilidad de registro conjunto, debemos salir del espacio logarítmico al espacio de probabilidad. Pero no podemos agregar las dos probabilidades verdaderas porque son demasiado pequeñas y debemos escalarlas y hacer la suma: y poner el resultado de nuevo en el espacio de registro luego vuelva a : en el espacio de registro agregando . $\sum_{s=\{0,1\}} e^{jll_s - max\_jll}$ $\log\sum_{s=\{0,1\}} e^{jll_s - max\_jll}$ $max\_jll+ \log\sum_{s=\{0,1\}} e^{jll_s - max\_jll}$ $max\_jll$

Y aquí está la derivación:

$\begin{align} \log \sum_{s=\{0,1\}} e^{jll_s} & = \log \sum_{s=\{0,1\}} e^{jll_s}e^{max\_jll-max\_jll} \\& = \log e ^{max\_jll}+ \log\sum_{s=\{0,1\}} e^{jll_s - max\_jll} \\& = max\_jll+ \log\sum_{s=\{0,1\}} e^{jll_s - max\_jll} \end{align}$

donde es el en el código. $max\_jll$ $a\_max$

Una vez que obtenemos tanto el numerador como el denominador en el espacio logarítmico, podemos obtener la probabilidad condicional logarítmica ( ) restando el denominador del numerador : $\log p(S=1|w_1, ... w_n)$

return jll - np.atleast_2d(log_prob_x).T

Espero que ayude.

Referencia:
1. Bernoulli Naive Bayes Classifier
2. Filtrado de spam con Naive Bayes - ¿Qué Naive Bayes?

Lerner Zhang
fuente