Esempio di come funziona il trucco log-sum-exp in Naive Bayes

Ho letto del trucco log-sum-exp in molti posti (ad esempio qui e qui ) ma non ho mai visto un esempio di come viene applicato in modo specifico al classificatore Naive Bayes (ad esempio con funzionalità discrete e due classi)

Come si eviterebbe esattamente il problema del underflow numerico usando questo trucco?

naive-bayes underflow

— Josh
fonte

Ci sono diversi esempi del suo uso qui, anche se non necessariamente esplicitamente per ingenui Bayes. Tuttavia, ciò non importa, dato che l'idea del trucco è abbastanza semplice e facilmente adattabile.

— Glen_b

È più probabile che il problema sia underflow che overflow.

— Henry,

Ti suggerirei di provare una ricerca su underflow e quindi di aggiornare la tua domanda per affrontare in modo più specifico tutto ciò che non è già coperto.

— Glen_b

Potresti anche chiarire: questa è l'ingenua Bayes modello Bernoulli? qualcos'altro forse?

— Glen_b

Vedi l'esempio qui , proprio in fondo (appena prima di 'Vedi anche' dove prendono i log; esponenziale su entrambi i lati ma lasciando RHS "così com'è" (come l'esp di una somma di log) sarebbe un esempio del log -sum-exp trucco. Ti dà informazioni sufficienti relative al suo utilizzo in Naive Bayes per porre una domanda più specifica?

— Glen_b -Reinstate Monica

Risposte:

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)}$

sia il denominatore che il numeratore possono diventare molto piccoli, in genere perché può essere vicino a 0 e moltipliciamo molti di loro l'uno con l'altro. Per evitare underflow, si può semplicemente prendere il registro del numeratore, ma è necessario utilizzare il trucco log-sum-exp per il denominatore. $p(x_i \vert C_k)$

Più specificamente, al fine di prevenire underflow:

Se ci interessa solo sapere a quale classe l'input molto probabilmente appartiene alla regola di decisione massima a posteriori (MAP), non lo facciamo dobbiamo applicare il trucco log-sum-exp, dal momento che non dobbiamo calcolare il denominatore in quel caso. Per il numeratore si può semplicemente prendere il registro per evitare underflow: . Più specificamente: $(\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)$
che diventa dopo aver preso il 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}$

Se vogliamo calcolare la probabilità di classe , dovremo calcolare il denominatore: $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}$

L'elemento potrebbe essere underflow perché può essere molto piccolo: è lo stesso problema del numeratore, ma questa volta abbiamo una somma all'interno del logaritmo, che ci impedisce di trasformare (può essere vicino a 0) in (negativo e non più vicino a 0, poiché ). Per aggirare questo problema, possiamo usare il fatto che per ottenere: $\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}))))$

A quel punto, sorge un nuovo problema: potrebbe essere abbastanza negativo, il che implica che può diventare molto vicino a 0, ovvero underflow. Qui è dove usiamo il trucco 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.$
Possiamo vedere che l'introduzione della variabile evita i underflow. Ad esempio con , abbiamo: $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}$
Usando il trucco log-sum-exp evitiamo il underflow, 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}$

Abbiamo evitato il underflow poiché è molto più lontano da 0 di o . $e^{-10}$ $3.96143\times 10^{- 107}$ $1.798486 \times 10^{-111}$

— Franck Dernoncourt
fonte

Supponiamo di voler identificare da quale dei due database è più probabile che abbia generato una frase (ad esempio, da quale romanzo è più probabile che questa frase provenga). Potremmo assumere l'indipendenza delle parole condizionate dal database (ipotesi Naive Bayes).

Ora cerca il secondo link che hai pubblicato. Là rappresenterebbe la probabilità congiunta di osservare la frase data un database e gli s rappresenterebbero la probabilità di osservare ciascuna delle parole nella frase. $a$ $e^{b_{t}}$

— Sid
fonte

Da questa risposta possiamo vedere che il numero più piccolo in Python (prendilo per esempio) è 5e-324dovuto all'IEEE754 , e la causa dell'hardware si applica anche ad altre lingue.

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

E qualsiasi galleggiante più piccolo di quello porterebbe a 0.

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

E vediamo la funzione di Naive Bayes with discrete features and two classescome richiesto:

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)}$

Consentitemi di creare un'istanza di tale funzione tramite un semplice muggito di attività NLP.

Decidiamo di rilevare se l'email in arrivo è spam ( ) o no spam ( ) e abbiamo un vocabolario di parole di 5.000 dimensioni ( ) e l'unica preoccupazione è se si verifica una parola ( ) ( ) nell'e-mail o meno ( ) per semplicità ( Bernoulli naive 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)

Possiamo vedere che sarebbe molto piccolo a causa delle probabilità (sia che sarebbe tra 0 e 1) in , e quindi siamo sicuri che il prodotto sarebbe più piccolo di e otterremo solo . $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

Quindi sorge il problema: come possiamo calcolare la probabilità che l'e-mail sia uno spam ? O come possiamo calcolare il numeratore e il denominatore? $p(S=1|w_1, ... w_n)$

Possiamo vedere l'implementazione ufficiale in 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

Per il numeratore ha convertito il prodotto delle probabilità nella somma della probabilità di log e per il denominatore ha usato il logsumexp in scipy che è:

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

Perché non possiamo aggiungere due probabilità congiunte aggiungendo la sua probabilità di registro comune e dovremmo uscire dallo spazio del registro allo spazio delle probabilità. Ma non possiamo aggiungere le due vere probabilità perché sono troppo piccole e dovremmo ridimensionarle e fare l'aggiunta: e rimettere il risultato nello spazio log quindi ridimensionalo nuovamente: nello spazio di registro aggiungendo . $\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$

Ed ecco la derivazione:

$\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}$

dove è la nel codice. $max\_jll$ $a\_max$

Una volta che abbiamo sia il numeratore che il denominatore nello spazio del registro, possiamo ottenere la probabilità condizionata del registro ( ) sottraendo il denominatore dal numeratore : $\log p(S=1|w_1, ... w_n)$

return jll - np.atleast_2d(log_prob_x).T

Spero possa aiutare.

Riferimento:
1. Classificazione di Bernoulli Naive Bayes
2. Filtro antispam con Naive Bayes - Quali Naive Bayes?

— Lerner Zhang
fonte