TechCodeview

• L'algoritmo Naïve Bayes è un algoritmo di apprendimento supervisionato, basato su Teorema di Bayes e utilizzato per risolvere problemi di classificazione.
• Viene utilizzato principalmente in classificazione del testo che include un set di dati di addestramento ad alta dimensione.
• Naïve Bayes Classifier è uno degli algoritmi di classificazione semplici ed efficaci che aiuta a costruire modelli di apprendimento automatico veloci in grado di fare previsioni rapide.
È un classificatore probabilistico, il che significa che prevede sulla base della probabilità di un oggetto.
• Alcuni esempi popolari di algoritmo Naïve Bayes sono filtraggio dello spam, analisi sentimentale e classificazione degli articoli .

Perché si chiama Naïve Bayes?

L'algoritmo Naïve Bayes è composto da due parole Naïve e Bayes, che possono essere descritte come:

Ingenuo: Si chiama Naïve perché presuppone che il verificarsi di una certa caratteristica sia indipendente dal verificarsi di altre caratteristiche. Ad esempio, se il frutto viene identificato in base al colore, alla forma e al gusto, allora il frutto rosso, sferico e dolce viene riconosciuto come una mela. Quindi ogni caratteristica contribuisce individualmente a identificare che si tratta di una mela senza dipendere l'una dall'altra.Bayes: Si chiama Bayes perché dipende dal principio del Teorema di Bayes.

Teorema di Bayes:

• Il teorema di Bayes è anche noto come Regola di Bayes O Legge di Bayes , che viene utilizzato per determinare la probabilità di un'ipotesi con conoscenza precedente. Dipende dalla probabilità condizionata.
• La formula del teorema di Bayes è data come:

Dove,

P(A|B) è la probabilità posteriore : Probabilità dell'ipotesi A sull'evento osservato B.

P(B|A) è la probabilità di verosimiglianza : Probabilità dell'evidenza dato che la probabilità di un'ipotesi è vera.

P(A) è la probabilità a priori : Probabilità dell'ipotesi prima di osservare l'evidenza.

P(B) è la probabilità marginale : Probabilità dell'evidenza.

Funzionamento del classificatore di Naïve Bayes:

Il funzionamento del classificatore di Naïve Bayes può essere compreso con l'aiuto dell'esempio seguente:

Supponiamo di avere un set di dati di condizioni meteo e la corrispondente variabile di destinazione ' Giocare '. Quindi, utilizzando questo set di dati dobbiamo decidere se giocare o meno in un giorno particolare in base alle condizioni meteorologiche. Quindi, per risolvere questo problema, dobbiamo seguire i passaggi seguenti:

1. Converti il ​​set di dati fornito in tabelle di frequenza.
2. Genera una tabella di verosimiglianza trovando le probabilità di determinate caratteristiche.
3. Ora, usa il teorema di Bayes per calcolare la probabilità a posteriori.

Problema : Se il tempo è soleggiato, il giocatore dovrebbe giocare oppure no?

Soluzione : Per risolvere questo problema, considera innanzitutto il set di dati seguente:

Tabella di frequenza per le condizioni meteorologiche:

Tabella delle probabilità delle condizioni meteorologiche:

Java che concatena stringhe

Applicando il teorema di Bayes:

P(Sì|Soleggiato)= P(Soleggiato|Sì)*P(Sì)/P(Soleggiato)

P(soleggiato|Sì)= 3/10= 0,3

P(soleggiato)= 0,35

P(Sì)=0,71

Quindi P(Sì|Soleggiato) = 0,3*0,71/0,35= 0,60

P(No|Soleggiato)= P(Soleggiato|No)*P(No)/P(Soleggiato)

P(soleggiato|NO)= 2/4=0,5

P(No)= 0,29

P(soleggiato)= 0,35

Quindi P(No|Soleggiato)= 0,5*0,29/0,35 = 0,41

Quindi, come possiamo vedere dal calcolo di cui sopra P(Sì|soleggiato)>P(No|soleggiato)

Quindi in una giornata soleggiata, il giocatore può giocare.

Vantaggi del classificatore Naïve Bayes:

• Naïve Bayes è uno degli algoritmi ML facili e veloci per prevedere una classe di set di dati.
• Può essere utilizzato per classificazioni binarie e multiclasse.
• Funziona bene nelle previsioni multiclasse rispetto agli altri algoritmi.
• È la scelta più popolare per problemi di classificazione del testo .

Svantaggi del classificatore Naïve Bayes:

• Naive Bayes presuppone che tutte le funzionalità siano indipendenti o non correlate, quindi non può apprendere la relazione tra le funzionalità.

Applicazioni del classificatore Naïve Bayes:

• È usato per Livello di crediti .
• È usato dentro classificazione dei dati medici .
• Può essere utilizzato in previsioni in tempo reale perché Naïve Bayes Classifier è uno studente desideroso.
• È utilizzato nella classificazione del testo come Filtraggio dello spam E Analisi del sentimento .

Tipi di modello Naïve Bayes:

Esistono tre tipi di modello Naive Bayes, riportati di seguito:

gaussiano: Il modello gaussiano presuppone che le caratteristiche seguano una distribuzione normale. Ciò significa che se i predittori assumono valori continui anziché discreti, il modello presuppone che questi valori siano campionati dalla distribuzione gaussiana.Multinomiale: Il classificatore Multinomial Naïve Bayes viene utilizzato quando i dati sono distribuiti multinomiale. Viene utilizzato principalmente per problemi di classificazione dei documenti, significa che un particolare documento appartiene a quale categoria come sport, politica, istruzione, ecc.
Il classificatore utilizza la frequenza delle parole per i predittori.Bernoulli: Il classificatore Bernoulli funziona in modo simile al classificatore multinomiale, ma le variabili predittive sono variabili booleane indipendenti. Ad esempio se una parola particolare è presente o meno in un documento. Questo modello è famoso anche per le attività di classificazione dei documenti.

Implementazione Python dell'algoritmo Naïve Bayes:

Ora implementeremo un algoritmo Naive Bayes utilizzando Python. Quindi per questo utilizzeremo il ' dati utente ' set di dati , che abbiamo utilizzato nell'altro nostro modello di classificazione. Pertanto possiamo facilmente confrontare il modello Naive Bayes con gli altri modelli.

Passaggi da implementare:

• Fase di pre-elaborazione dei dati
• Adattare Naive Bayes al set di allenamento
• Predire il risultato del test
• Verifica l'accuratezza del risultato (creazione della matrice di confusione)
• Visualizzazione del risultato del set di test.

1) Fase di pre-elaborazione dei dati:

In questo passaggio, pre-elaboreremo/prepareremo i dati in modo da poterli utilizzare in modo efficiente nel nostro codice. È simile a quello che abbiamo fatto nella pre-elaborazione dei dati. Il codice per questo è riportato di seguito:

 Importing the libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd # Importing the dataset dataset = pd.read_csv('user_data.csv') x = dataset.iloc[:, [2, 3]].values y = dataset.iloc[:, 4].values # Splitting the dataset into the Training set and Test set from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.25, random_state = 0) # Feature Scaling from sklearn.preprocessing import StandardScaler sc = StandardScaler() x_train = sc.fit_transform(x_train) x_test = sc.transform(x_test) 

Nel codice sopra, abbiamo caricato il set di dati nel nostro programma utilizzando ' set di dati = pd.read_csv('utente_data.csv') . Il set di dati caricato è diviso in set di training e set di test, quindi abbiamo ridimensionato la variabile della funzionalità.

L'output per il set di dati è dato come:

2) Adattare Naive Bayes al set di allenamento:

Dopo la fase di pre-elaborazione, ora adatteremo il modello Naive Bayes al set di allenamento. Di seguito è riportato il codice:

 # Fitting Naive Bayes to the Training set from sklearn.naive_bayes import GaussianNB classifier = GaussianNB() classifier.fit(x_train, y_train) 

Nel codice sopra abbiamo utilizzato il file Classificatore gaussianoNB per adattarlo al set di dati di addestramento. Possiamo anche utilizzare altri classificatori secondo le nostre esigenze.

Produzione:

 Out[6]: GaussianNB(priors=None, var_smoothing=1e-09) 

3) Previsione del risultato del test set:

Ora prevederemo il risultato del set di test. Per questo, creeremo una nuova variabile predittrice y_pred e utilizzerà la funzione di previsione per effettuare le previsioni.

 # Predicting the Test set results y_pred = classifier.predict(x_test) 

Produzione:

L'output sopra mostra il risultato per il vettore di previsione y_pred e il vettore reale y_test. Possiamo vedere che alcune previsioni sono diverse dai valori reali, che sono previsioni errate.

4) Creazione della matrice di confusione:

Ora controlleremo l'accuratezza del classificatore Naive Bayes utilizzando la matrice di confusione. Di seguito è riportato il codice:

 # Making the Confusion Matrix from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_test, y_pred) 

Produzione:

Come possiamo vedere nell'output della matrice di confusione sopra, ci sono 7+3= 10 previsioni errate e 65+25=90 previsioni corrette.

5) Visualizzazione del risultato del training set:

Successivamente visualizzeremo il risultato del set di training utilizzando il classificatore Na�ve Bayes. Di seguito è riportato il codice:

 # Visualising the Training set results from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train X1, X2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step = 0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(X1, X2, classifier.predict(nm.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape), alpha = 0.75, cmap = ListedColormap(('purple', 'green'))) mtp.xlim(X1.min(), X1.max()) mtp.ylim(X2.min(), X2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Naive Bayes (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Produzione:

Nell'output sopra possiamo vedere che il classificatore Na�ve Bayes ha separato i punti dati con il confine fine. È la curva gaussiana come abbiamo usato GaussianoNB classificatore nel nostro codice.

6) Visualizzazione del risultato del test set:

 # Visualising the Test set results from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test X1, X2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step = 0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(X1, X2, classifier.predict(nm.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape), alpha = 0.75, cmap = ListedColormap(('purple', 'green'))) mtp.xlim(X1.min(), X1.max()) mtp.ylim(X2.min(), X2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Naive Bayes (test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Produzione:

L'output sopra riportato è l'output finale per i dati del set di test. Come possiamo vedere il classificatore ha creato una curva gaussiana per dividere le variabili 'acquistato' e 'non acquistato'. Ci sono alcune previsioni errate che abbiamo calcolato nella matrice di confusione. Ma è comunque un buon classificatore.