Algoritmo Naïve-Bayes

L'algoritmo Naïve-Bayes è un metodo di classificazione che si basa sul Teorema di Bayes, applicato in modo "naïve" assumendo l'indipendenza condizionale tra le caratteristiche.
Questo significa che, nonostante la presenza dell'assunzione di indipendenza, l'algoritmo può ancora funzionare bene in molte situazioni del mondo reale.

Teorema di Bayes

Il Teorema di Bayes è una formula che calcola la probabilità di un evento basandosi su informazioni preesistenti.
La sua forma generale è:
\[ P(A|B) = \frac{P(B|A) \cdot P(A)}{P(B)} \]

Dove:
- \( P(A|B) \) è la probabilità condizionale di A dato B.
- \( P(B|A) \) è la probabilità condizionale di B dato A.
- \( P(A) \) e \( P(B) \) sono le probabilità marginali di A e B, rispettivamente.

Algoritmo Naïve-Bayes

L'algoritmo Naïve-Bayes utilizza il Teorema di Bayes per stimare la probabilità condizionale di una classe dato un insieme di caratteristiche.
L'assunzione chiave è che le caratteristiche siano indipendenti, quindi la probabilità congiunta delle caratteristiche può essere approssimata come il prodotto delle probabilità condizionali di ciascuna caratteristica.

Esempio con Python e Matplotlib

In questo esempio, useremo il dataset Iris per una classificazione con l'algoritmo Naïve-Bayes.
Utilizzeremo la libreria scikit-learn per implementare l'algoritmo e Matplotlib per visualizzare i risultati.

# Import delle librerie
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn import datasets
import matplotlib.pyplot as plt
import seaborn as sns

# Caricamento del dataset Iris
iris = datasets.load_iris()
X = iris.data
y = iris.target

# Suddivisione del dataset in training set e test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Creazione del modello Gaussian Naïve-Bayes
model = GaussianNB()

# Addestramento del modello
model.fit(X_train, y_train)

# Predizione sul test set
y_pred = model.predict(X_test)

# Visualizzazione dei risultati
plt.scatter(X_test[:, 0], X_test[:, 1], c=y_pred, cmap='viridis', edgecolors='k', s=100, label='Predicted Class')
plt.xlabel(iris.feature_names[0])
plt.ylabel(iris.feature_names[1])
plt.title('Naïve-Bayes Classification')
plt.legend()
plt.show()

cm = confusion_matrix(y_test, y_pred)

# Calcolo dell'accuratezza
accuracy = accuracy_score(y_test, y_pred)

# Visualizzazione della matrice di confusione con seaborn
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues")
plt.xlabel('Predicted')
plt.ylabel('True')
plt.title('Confusion Matrix')
plt.show()

# Visualizzazione dell'accuratezza
print(f'Accuracy: {accuracy:.2f}')

Questo esempio utilizza il modello Naïve-Bayes Gaussiano per classificare il dataset Iris in tre classi.
La matrice di confusione visualizzata con Matplotlib mostra la precisione del modello per ciascuna classe.

Matrice di Confusione

Una matrice di confusione è uno strumento utilizzato nel machine learning per valutare le prestazioni di un modello di classificazione.
Questa matrice mostra il confronto tra le previsioni effettuate dal modello e i veri valori di classe del dataset.

La matrice di confusione è organizzata in modo da visualizzare quattro categorie principali:

• True Positives (TP): I casi in cui il modello ha previsto correttamente la classe positiva.
• True Negatives (TN): I casi in cui il modello ha previsto correttamente la classe negativa.
• False Positives (FP): I casi in cui il modello ha previsto erroneamente la classe positiva quando in realtà era negativa (falso allarme).
• False Negatives (FN): I casi in cui il modello ha previsto erroneamente la classe negativa quando in realtà era positiva (mancata individuazione).

Utilizzo nel Machine Learning

La matrice di confusione fornisce una panoramica dettagliata delle prestazioni di un modello di classificazione. Da essa, è possibile calcolare diverse metriche di valutazione, tra cui:
- Precisione (Precision): \( \frac{TP}{TP + FP} \) - La percentuale di previsioni positive del modello che sono effettivamente corrette.
- Recall o Sensibilità (Recall): \( \frac{TP}{TP + FN} \) - La percentuale di casi positivi effettivamente individuati dal modello.
- F1-Score: Una media ponderata di precisione e recall (\(2 \cdot \frac{\text{Precision} \cdot \text{Recall}}{\text{Precision} + \text{Recall}}\)) che bilancia entrambe le metriche.
- Specificità (Specificity): \( \frac{TN}{TN + FP} \) - La percentuale di casi negativi effettivamente individuati dal modello.

Esempio

Immagina di avere un modello di classificazione che predice se un'email è spam o non spam. La matrice di confusione potrebbe apparire così:

                Actual Spam      Actual Non-Spam
Predicted Spam    120 (TP)            10 (FP)
Predicted Non-Spam  5 (FN)            865 (TN)

    

In questo esempio:
- Ci sono 120 casi in cui il modello ha correttamente previsto che un'email è spam (True Positives).
- Ci sono 865 casi in cui il modello ha correttamente previsto che un'email non è spam (True Negatives). - Ci sono 10 casi in cui il modello ha erroneamente predetto che un'email è spam quando non lo è (False Positives).
- Ci sono 5 casi in cui il modello ha erroneamente predetto che un'email non è spam quando lo è (False Negatives).
La matrice di confusione consente di valutare le performance del modello e di calcolare metriche specifiche per la classificazione binaria.