L’algoritmo Naive Bayes è un classificatore probabilistico basato sul teorema di Bayes. È spesso utilizzato per problemi di classificazione, in cui l’obiettivo è assegnare una classe o una categoria a un insieme di dati in base a determinate caratteristiche. L’approccio “naive” (ingenuo) deriva dall’assunzione di indipendenza condizionale delle caratteristiche, il che semplifica il calcolo delle probabilità.
[wpda_org_chart tree_id=18 theme_id=50]
I Classificatori Naive Bayes in Scikit-Learn
In Python, puoi utilizzare la libreria scikit-learn per implementare il classificatore Naive Bayes. Ci sono principalmente tre tipi di classificatori Naive Bayes offerti da scikit-learn:
- Gaussian Naive Bayes: Questo è adatto per dati continui in cui si assume che le caratteristiche seguano una distribuzione gaussiana (normale).
- Multinomial Naive Bayes: Questo è utilizzato principalmente per dati discreti come testi. È spesso applicato nell’analisi di testi, ad esempio per la classificazione di documenti.
- Bernoulli Naive Bayes: Questo è simile al multinomiale, ma è utilizzato per dati binari, come ad esempio la presenza o l’assenza di determinate parole in un documento.
Gaussian Naive Bayes
Il Gaussian Naive Bayes è una variante del classificatore Naive Bayes che assume che le feature del dataset siano distribuite secondo una distribuzione normale (Gaussiana). Il Naive Bayes è un algoritmo di classificazione basato sul Teorema di Bayes, che sfrutta l’indipendenza condizionale tra le feature dato un’etichetta di classe. In questo particolare caso, si assume che la distribuzione delle feature dato un’etichetta di classe sia gaussiana (normale). Questa assunzione semplifica ulteriormente il calcolo delle probabilità condizionali.
Ecco un esempio di come utilizzare il classificatore Gaussian Naive Bayes:
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.datasets import make_classification
# Generiamo un dataset di esempio
X, y = make_classification(n_samples=100, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=42)
# Dividiamo il dataset in set di addestramento e di test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Addestramento del modello Gaussian Naive Bayes
gnb = GaussianNB()
gnb.fit(X_train, y_train)
# Valutazione dell'accuratezza del modello
accuracy = gnb.score(X_test, y_test)
print(f'Accuratezza del modello: {accuracy:.2f}')
# Creiamo una meshgrid per visualizzare la decision boundary
h = .02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
# Prevediamo le classi per ciascun punto nella meshgrid
Z = gnb.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
# Visualizziamo i punti del dataset e la decision boundary
plt.contourf(xx, yy, Z, cmap=plt.cm.RdYlBu, alpha=0.3)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.RdYlBu, edgecolors='k', marker='o')
plt.title('Gaussian Naive Bayes - Decision Boundary')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.show()
Se vuoi approfondire l’argomento e scoprire di più sul mondo della Data Science con Python, ti consiglio di leggere il mio libro:
Fabio Nelli
Analizziamo insieme le varie parti del codice.
- Generazione del dataset di esempio:
X, y = make_classification(n_samples=100, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=42)Utilizziamo la funzione make_classification di scikit-learn per generare un dataset di esempio con 100 campioni, 2 feature informative, 0 feature ridondanti, e 1 cluster per classe.
- Divisione del dataset in set di addestramento e test:
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)Dividiamo il dataset generato in set di addestramento (80%) e di test (20%).
- Addestramento del modello Gaussian Naive Bayes:
gnb = GaussianNB()
gnb.fit(X_train, y_train)Creiamo un’istanza del modello Gaussian Naive Bayes (GaussianNB), lo addestriamo sul set di addestramento utilizzando il metodo fit.
- Valutazione dell’accuratezza del modello:
accuracy = gnb.score(X_test, y_test)
print(f'Accuratezza del modello: {accuracy:.2f}')Calcoliamo l’accuratezza del modello sui dati di test utilizzando il metodo score che restituisce l’accuratezza del modello rispetto ai dati di test.
- Creazione di una meshgrid per la visualizzazione della decision boundary:
h = .02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))Creiamo una meshgrid per coprire lo spazio delle feature.
- Previsione delle classi per ciascun punto nella meshgrid:
Z = gnb.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)Applichiamo la previsione del modello Gaussian Naive Bayes a ciascun punto della meshgrid.
- Visualizzazione dei risultati:
plt.contourf(xx, yy, Z, cmap=plt.cm.RdYlBu, alpha=0.3)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.RdYlBu, edgecolors='k', marker='o')
plt.title('Gaussian Naive Bayes - Decision Boundary')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.show()Eseguendo infine il codice si otterrà come valore di accuratezza:
Accuratezza del modello: 0.90Ed in seguito verrà visualizzato il seguente grafico.
Sono rappresentati i punti del dataset e la decision boundary generata dal modello. I punti del dataset sono colorati in base alla loro classe, mentre l’area colorata rappresenta la decision boundary prevista dal modello Gaussian Naive Bayes.
Questo esempio illustra il processo di addestramento e valutazione di un classificatore Gaussian Naive Bayes, oltre alla visualizzazione della decision boundary ottenuta.
Vantaggi e considerazioni:
- Semplicità: Il Gaussian Naive Bayes è noto per la sua semplicità e facilità d’implementazione.
- Buone prestazioni con dati ben approssimati dalla Gaussiana: Funziona particolarmente bene quando l’assunzione di distribuzione normale è ragionevolmente accurata per le feature del dataset.
Limitazioni:
- Assunzioni semplificative: L’assunzione di indipendenza condizionale e la distribuzione gaussiana possono risultare troppo semplificate per dataset complessi o con feature fortemente correlate.
- Sensibile a outliers: Essendo basato sulla distribuzione normale, è sensibile agli outliers nelle feature.
In sintesi, il Gaussian Naive Bayes è un classificatore efficiente e facile da implementare, particolarmente utile quando le assunzioni sulla distribuzione delle feature sono ragionevolmente valide per il dataset in esame. Tuttavia, è importante considerare le limitazioni e valutare attentamente la sua idoneità per il particolare problema di classificazione che si sta affrontando.
Multinomial Naive Bayes
Il Multinomial Naive Bayes è una variante del classificatore Naive Bayes specificamente progettata per dati discreti o conteggio di frequenze, tipicamente utilizzati in task di classificazione di testi. Questo algoritmo assume che le feature siano rappresentate da distribuzioni multinomiali, il che lo rende particolarmente adatto per dati come conteggi di parole nei documenti.
- Teorema di Bayes:
Il Multinomial Naive Bayes utilizza il Teorema di Bayes per calcolare le probabilità a posteriori delle classi dati i conteggi delle feature. - Assunzione di indipendenza condizionale:
Come il classificatore Naive Bayes standard, il Multinomial Naive Bayes assume l’indipendenza condizionale delle feature dato l’etichetta di classe. Questa assunzione semplifica il calcolo delle probabilità condizionali. - Distribuzione multinomiale:
Si assume che la distribuzione delle feature, rappresentate dai conteggi, segua una distribuzione multinomiale. Ciò significa che il modello tiene conto delle frequenze di ciascuna parola o feature all’interno di una classe.
Applicazioni tipiche:
- Classificazione di testi:
Il Multinomial Naive Bayes è ampiamente utilizzato nella classificazione di testi, come la categorizzazione di documenti, il filtraggio dello spam, l’analisi del sentimento e altro ancora. - Rappresentazione dei dati:
È comunemente utilizzato quando le feature possono essere rappresentate come conteggi di frequenze, ad esempio il numero di occorrenze di ciascuna parola in un documento.
Vediamo un esempio su come applicare questo algoritmo
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
# Dati di esempio: documenti e relative etichette binarie
documents = [
"This is a technology article about artificial intelligence.",
"A recipe for a delicious chocolate cake.",
"Tips for effective time management.",
"Latest fashion trends for the season.",
"Overview of sustainable energy sources.",
"How to improve your programming skills.",
"Healthy lifestyle habits for longevity.",
"Travel guide to exotic destinations.",
]
# Assegniamo etichette binarie per indicare se il documento è tecnologico o no
labels = [1, 0, 0, 0, 1, 1, 0, 0]
# Creazione di una matrice di conteggi delle parole
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(documents)
# Divisione del dataset in set di addestramento e test
X_train, X_test, y_train, y_test = train_test_split(X, labels, test_size=0.2, random_state=42)
# Addestramento del modello Multinomial Naive Bayes
mnb = MultinomialNB()
mnb.fit(X_train, y_train)
# Valutazione dell'accuratezza del modello
y_pred = mnb.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuratezza del modello: {accuracy:.2f}')
# Report di classificazione
print("Report di classificazione:")
print(classification_report(y_test, y_pred, zero_division=1))Certamente, analizziamo le varie parti del codice:
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report- Import delle librerie:
CountVectorizer: Un metodo di scikit-learn che converte una collezione di documenti di testo in una matrice di conteggi delle parole.MultinomialNB: L’implementazione di scikit-learn del classificatore Naive Bayes multinomiale.train_test_split: Una funzione di scikit-learn che divide il dataset in set di addestramento e test.accuracy_score: Una funzione di scikit-learn per calcolare l’accuratezza del modello.classification_report: Una funzione di scikit-learn che genera un report dettagliato delle metriche di classificazione.
# Dati di esempio: documenti e relative etichette binarie
documents = [
"This is a technology article about artificial intelligence.",
"A recipe for a delicious chocolate cake.",
"Tips for effective time management.",
"Latest fashion trends for the season.",
"Overview of sustainable energy sources.",
"How to improve your programming skills.",
"Healthy lifestyle habits for longevity.",
"Travel guide to exotic destinations.",
]
# Assegniamo etichette binarie per indicare se il documento è tecnologico o no
labels = [1, 0, 0, 0, 1, 1, 0, 0]- Definizione dei dati:
documents: Una lista di documenti di testo rappresentanti vari argomenti.labels: Una lista di etichette binarie (1 per documenti tecnologici, 0 per gli altri).
# Creazione di una matrice di conteggi delle parole
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(documents)- Creazione della matrice di conteggi delle parole:
CountVectorizer: Un metodo di scikit-learn che converte i documenti di testo in una matrice di conteggi delle parole.fit_transform: Addestra ilvectorizere trasforma i documenti in una matrice di conteggi delle parole.
# Divisione del dataset in set di addestramento e test
X_train, X_test, y_train, y_test = train_test_split(X, labels, test_size=0.2, random_state=42)- Divisione del dataset:
train_test_split: Una funzione di scikit-learn che suddivide il dataset in set di addestramento e test.
# Addestramento del modello Multinomial Naive Bayes
mnb = MultinomialNB()
mnb.fit(X_train, y_train)- Addestramento del modello:
MultinomialNB: Il classificatore Naive Bayes multinomiale di scikit-learn.fit: Addestra il modello sul set di addestramento.
# Valutazione dell'accuratezza del modello
y_pred = mnb.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuratezza del modello: {accuracy:.2f}')- Valutazione del modello:
accuracy_score: Calcola l’accuratezza del modello confrontando le previsioni con le etichette di test.predict: Prevede le etichette per il set di test.- Stampa l’accuratezza del modello.
# Report di classificazione con gestione di zero_division
print("Report di classificazione:")
print(classification_report(y_test, y_pred, zero_division=1))- Report di classificazione:
classification_report: Genera un report dettagliato delle metriche di classificazione (precision, recall, F1-score).zero_division=1: Gestisce il caso in cui ci siano divisioni per zero, impostando i valori a 1 nelle metriche. Può essere regolato in base alle esigenze.
Eseguendo si ottiene il seguente risultato:
Accuratezza del modello: 0.50
Report di classificazione:
precision recall f1-score support
0 0.50 1.00 0.67 1
1 1.00 0.00 0.00 1
accuracy 0.50 2
macro avg 0.75 0.50 0.33 2
weighted avg 0.75 0.50 0.33 2.
Libro Suggerito
Se sei interessato al Machine Learning e ti piace programmare in Python ti suggerisco di leggere questo libro:
Bernoulli Naive Bayes
Il Bernoulli Naive Bayes è un’altra variante del classificatore Naive Bayes che si basa sulla distribuzione di Bernoulli delle feature. Questa variante è spesso utilizzata quando si tratta di dati binari, dove le feature possono essere presenti (1) o assenti (0).
Principi fondamentali:
- Teorema di Bayes:
Il Bernoulli Naive Bayes applica il Teorema di Bayes per calcolare le probabilità a posteriori delle classi dato il vettore binario delle feature. - Assunzione di indipendenza condizionale:
Come altri classificatori Naive Bayes, il Bernoulli Naive Bayes assume l’indipendenza condizionale delle feature dato l’etichetta di classe. Questo semplifica il calcolo delle probabilità condizionali. - Distribuzione di Bernoulli:
Si assume che la distribuzione delle feature sia di tipo Bernoulli, cioè le feature sono binarie (0 o 1).
Applicazioni tipiche:
- Dati binari:
È comunemente utilizzato quando le feature sono rappresentate da dati binari, come la presenza o assenza di parole in un documento. - Classificazione di testi:
Può essere applicato a problemi di classificazione di testi, specialmente quando si utilizzano rappresentazioni binarie delle parole (ad esempio, attraverso la tecnica di binarizzazione di TF-IDF).
Esempio con il codice Python:
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import BernoulliNB
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt
# Generiamo un dataset di esempio bilanciato
X, y = make_classification(n_samples=100, n_features=20, n_classes=2, n_clusters_per_class=1, random_state=42)
# Divisione del dataset in set di addestramento e test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Addestramento del modello Bernoulli Naive Bayes
bnb = BernoulliNB()
bnb.fit(X_train, y_train)
# Valutazione dell'accuratezza del modello
y_pred = bnb.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f'Model Accuracy: {accuracy:.2f}')
# Report di classificazione
print("Classification Report:")
print(classification_report(y_test, y_pred))
# Matrice di confusione
cm = confusion_matrix(y_test, y_pred)
# Visualizzazione della matrice di confusione
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", cbar=False,
xticklabels=["Negative", "Positive"],
yticklabels=["Negative", "Positive"])
plt.xlabel("Predicted")
plt.ylabel("True")
plt.title("Confusion Matrix")
plt.show()Eseguendo si otterrà il seguente risultato:
Model Accuracy: 1.00
Classification Report:
precision recall f1-score support
0 1.00 1.00 1.00 10
1 1.00 1.00 1.00 10
accuracy 1.00 20
macro avg 1.00 1.00 1.00 20
weighted avg 1.00 1.00 1.00 20Con una matrice di confusione per visualizzare meglio i risultati della classificazione da parte del modello.
