Naive Bayes Klassifizierung Tutorial mit Scikit-learn

Klassifizierungs-Workflow

Wenn du eine Klassifizierung durchführst, ist der erste Schritt, das Problem zu verstehen und mögliche Merkmale und Bezeichnungen zu identifizieren. Merkmale sind die Eigenschaften oder Attribute, die die Ergebnisse des Labels beeinflussen. Bei einer Kreditvergabe zum Beispiel ermitteln die Bankmanager den Beruf, das Einkommen, das Alter, den Wohnort, die bisherige Kredithistorie, die Transaktionshistorie und die Kreditwürdigkeit des Kunden. Diese Merkmale werden als Features bezeichnet und helfen dem Modell, die Kunden zu klassifizieren.

Die Klassifizierung besteht aus zwei Phasen, einer Lernphase und der Bewertungsphase. In der Lernphase trainiert der Klassifikator sein Modell auf einem bestimmten Datensatz, und in der Bewertungsphase wird die Leistung des Klassifikators getestet. Die Leistung wird anhand von verschiedenen Parametern wie Genauigkeit, Fehler, Präzision und Wiedererkennung bewertet.

Was ist ein Naive Bayes-Klassifikator?

Naive Bayes ist eine statistische Klassifizierungstechnik, die auf dem Bayes-Theorem basiert. Er ist einer der einfachsten überwachten Lernalgorithmen. Der Naive Bayes-Klassifikator ist ein schneller, genauer und zuverlässiger Algorithmus. Naive Bayes-Klassifikatoren haben eine hohe Genauigkeit und Geschwindigkeit bei großen Datensätzen.

Der Naive Bayes-Klassifikator geht davon aus, dass die Wirkung eines bestimmten Merkmals in einer Klasse unabhängig von anderen Merkmalen ist. Zum Beispiel ist ein Kreditantragsteller abhängig von seinem Einkommen, seiner bisherigen Kredit- und Transaktionsgeschichte, seinem Alter und seinem Wohnort erwünscht oder nicht. Auch wenn diese Merkmale voneinander abhängig sind, werden sie dennoch unabhängig voneinander betrachtet. Diese Annahme vereinfacht die Berechnungen und wird deshalb als naiv bezeichnet. Diese Annahme wird als bedingte Klassenunabhängigkeit bezeichnet.

• P(h): die Wahrscheinlichkeit, dass die Hypothese h wahr ist (unabhängig von den Daten). Dies wird als Vorwahrscheinlichkeit von h bezeichnet.
• P(D): die Wahrscheinlichkeit der Daten (unabhängig von der Hypothese). Dies wird als Vorwahrscheinlichkeit bezeichnet.
• P(h|D): die Wahrscheinlichkeit der Hypothese h bei Vorliegen der Daten D. Dies wird als Posteriorwahrscheinlichkeit bezeichnet.
• P(D|h): die Wahrscheinlichkeit, dass die Daten d wahr sind, wenn die Hypothese h wahr ist. Dies wird als Nachhersagewahrscheinlichkeit bezeichnet.

Wie funktioniert der Naive Bayes Classifier?

Lass uns die Funktionsweise von Naive Bayes anhand eines Beispiels verstehen. Gib ein Beispiel für Wetterbedingungen und Sport. Du musst die Wahrscheinlichkeit des Sporttreibens berechnen. Jetzt musst du anhand der Wetterbedingungen festlegen, ob die Spieler spielen werden oder nicht.

Erster Ansatz (im Falle eines einzelnen Merkmals)

Der Naive Bayes-Klassifikator berechnet die Wahrscheinlichkeit eines Ereignisses in den folgenden Schritten:

• Schritt 1: Berechne die vorherige Wahrscheinlichkeit für gegebene Klassenbezeichnungen
• Schritt 2: Finde die Wahrscheinlichkeit mit jedem Attribut für jede Klasse
• Schritt 3: Setze diese Werte in die Bayes-Formel ein und berechne die Nachfolgewahrscheinlichkeit.
• Schritt 4: Finde heraus, welche Klasse eine höhere Wahrscheinlichkeit hat, wenn die Eingabe zu der Klasse mit der höheren Wahrscheinlichkeit gehört.

Um die Berechnung der Prior- und Posteriorwahrscheinlichkeit zu vereinfachen, kannst du die beiden Tabellen Häufigkeits- und Wahrscheinlichkeitstabellen verwenden. Diese beiden Tabellen helfen dir bei der Berechnung der Prior- und Posteriorwahrscheinlichkeit. Die Häufigkeitstabelle enthält das Auftreten von Bezeichnungen für alle Merkmale. Es gibt zwei Wahrscheinlichkeitstafeln. Wahrscheinlichkeitstabelle 1 zeigt die Vorwahrscheinlichkeiten der Bezeichnungen und Wahrscheinlichkeitstabelle 2 zeigt die Nachwahrscheinlichkeit.

Angenommen, du willst die Wahrscheinlichkeit berechnen, dass du bei bedecktem Himmel spielst.

Die Wahrscheinlichkeit zu spielen:

P(Ja | Bewölkt) = P(Bewölkt | Ja) P(Ja) / P (Bewölkt) .....................(1)

1. Berechne vorherige Wahrscheinlichkeiten:

   P(Bewölkt) = 4/14 = 0,29

   P(Ja)= 9/14 = 0,64

1. Berechne Posterior-Wahrscheinlichkeiten:

   P(Bewölkt |Ja) = 4/9 = 0,44

1. Setze Prior- und Posterior-Wahrscheinlichkeiten in Gleichung (1) ein

   P (Ja | Bewölkt) = 0,44 * 0,64 / 0,29 = 0,98(Höher)

Genauso kannst du die Wahrscheinlichkeit berechnen, dass du nicht spielst:

Die Wahrscheinlichkeit, nicht zu spielen:

P(Nein | Bewölkt) = P(Bewölkt | Nein) P(Nein) / P (Bewölkt) .....................(2)

1. Berechne vorherige Wahrscheinlichkeiten:

   P(Bewölkt) = 4/14 = 0,29

   P(Nein)= 5/14 = 0,36

1. Berechne Posterior-Wahrscheinlichkeiten:

   P(Bewölkt |Nein) = 0/9 = 0

1. Setze Prior- und Posterior-Wahrscheinlichkeiten in Gleichung (2) ein

   P (Nein | Bewölkt) = 0 * 0,36 / 0,29 = 0

Die Wahrscheinlichkeit einer "Ja"-Klasse ist höher. So kannst du hier feststellen, ob das Wetter bedeckt ist und die Spieler den Sport spielen werden.

Zweiter Ansatz (im Falle von mehreren Merkmalen)

Angenommen, du willst die Wahrscheinlichkeit berechnen, dass du bei bedecktem Himmel und milden Temperaturen spielst.

Die Wahrscheinlichkeit zu spielen:

P(Spiel=Ja | Wetter=Bewölkt, Temp=Mild) = P(Wetter=Bewölkt, Temp=Mild | Spiel=Ja)P(Spiel=Ja) ..........(1)

P(Wetter=Bewölkt, Temp=Mild | Spiel= Ja)= P(Bewölkt |Ja) P(Mild |Ja) ...........(2)

1. Berechne vorherige Wahrscheinlichkeiten: P(Ja)= 9/14 = 0,64

2. Berechne Posterior-Wahrscheinlichkeiten: P(Bewölkt |Ja) = 4/9 = 0,44 P(Mild |Ja) = 4/9 = 0,44

3. Setze die Posterior-Wahrscheinlichkeiten in Gleichung (2) ein P(Wetter=Overcast, Temp=Mild | Spielen= Ja) = 0,44 * 0,44 = 0,1936(Höher)

4. Setze Prior- und Posterior-Wahrscheinlichkeiten in Gleichung (1) ein P(Spiel=Ja | Wetter=Overcast, Temp=Mild) = 0,1936*0,64 = 0,124

Genauso kannst du die Wahrscheinlichkeit berechnen, dass du nicht spielst:

Die Wahrscheinlichkeit, nicht zu spielen:

P(Spiel= Nein | Wetter=Bewölkt, Temp=Mild) = P(Wetter=Bewölkt, Temp=Mild | Spiel= Nein)P(Spiel=Nein) ..........(3)

P(Wetter=Bewölkt, Temp=Mild | Spiel=Nein)= P(Wetter=Bewölkt |Spiel=Nein) P(Temp=Mild | Spiel=Nein) ...........(4)

1. Berechne vorherige Wahrscheinlichkeiten: P(Nein)= 5/14 = 0,36

2. Berechne Posterior-Wahrscheinlichkeiten: P(Wetter=Bewölkt |Spielen=Nein) = 0/9 = 0 P(Temp=Mild | Spielen=Nein)=2/5=0.4

3. Setze die nachträglichen Wahrscheinlichkeiten in Gleichung (4) ein P(Wetter=Overcast, Temp=Mild | Spiel= Nein) = 0 * 0,4= 0

4. Setze Prior- und Posterior-Wahrscheinlichkeiten in Gleichung (3) ein P(Spiel= Nein | Wetter=Overcast, Temp=Mild) = 0*0.36=0

Die Wahrscheinlichkeit einer "Ja"-Klasse ist höher. Man kann also sagen: Wenn das Wetter bedeckt ist, werden die Spieler den Sport spielen.

Erstellung von Klassifikatoren in Scikit-learn

Naive Bayes Klassifikator mit synthetischem Datensatz

Im ersten Beispiel werden wir mit scikit-learn synthetische Daten erzeugen und den Gauß-Naive-Bayes-Algorithmus trainieren und bewerten. 

Generierung des Datensatzes

Scikit-learn stellt uns ein Ökosystem für maschinelles Lernen zur Verfügung, mit dem du einen Datensatz erstellen und verschiedene Algorithmen für maschinelles Lernen testen kannst. 

In unserem Fall erstellen wir mit der Funktion `make_classification` einen Datensatz mit sechs Merkmalen, drei Klassen und 800 Stichproben. 

from sklearn.datasets import make_classification

X, y = make_classification(
    n_features=6,
    n_classes=3,
    n_samples=800,
    n_informative=2,
    random_state=1,
    n_clusters_per_class=1,
)

Wir werden die Funktion "scatter" von matplotlib.pyplot verwenden, um den Datensatz zu visualisieren. 

import matplotlib.pyplot as plt

plt.scatter(X[:, 0], X[:, 1], c=y, marker="*");

Wie wir sehen können, gibt es drei Arten von Zielkennzeichnungen und wir werden ein Mehrklassen-Klassifizierungsmodell trainieren. 

Zug Test Split

Bevor wir mit dem Trainingsprozess beginnen, müssen wir den Datensatz für die Modellbewertung in Training und Test aufteilen. 

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.33, random_state=125
)

Modellbau und Ausbildung 

Erstelle ein generisches Gaussian Naive Bayes und trainiere es auf einem Trainingsdatensatz. Danach fütterst du das Modell mit einer zufälligen Stichprobe, um einen vorhergesagten Wert zu erhalten.

from sklearn.naive_bayes import GaussianNB

# Build a Gaussian Classifier
model = GaussianNB()

# Model training
model.fit(X_train, y_train)

# Predict Output
predicted = model.predict([X_test[6]])

print("Actual Value:", y_test[6])
print("Predicted Value:", predicted[0])

Die tatsächlichen und die vorhergesagten Werte sind identisch. 

Actual Value: 0
Predicted Value: 0

Modellbewertung

Wir werden das Modell nicht auf einem ungesehenen Testdatensatz weiterentwickeln. Zuerst werden wir die Werte für den Testdatensatz vorhersagen und sie zur Berechnung der Genauigkeit und des F1-Scores verwenden. 

from sklearn.metrics import (
    accuracy_score,
    confusion_matrix,
    ConfusionMatrixDisplay,
    f1_score,
)

y_pred = model.predict(X_test)
accuray = accuracy_score(y_pred, y_test)
f1 = f1_score(y_pred, y_test, average="weighted")

print("Accuracy:", accuray)
print("F1 Score:", f1)

Unser Modell hat mit den Standard-Hyperparametern recht gut funktioniert. 

Accuracy: 0.8484848484848485
F1 Score: 0.8491119695890328

Um die Konfusionsmatrix zu visualisieren, verwenden wir `confusion_matrix`, um die wahren Positiven und wahren Negativen zu berechnen und `ConfusionMatrixDisplay`, um die Konfusionsmatrix mit den Beschriftungen anzuzeigen.

labels = [0,1,2]
cm = confusion_matrix(y_test, y_pred, labels=labels)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=labels)
disp.plot();

Unser Modell hat recht gut abgeschnitten, und wir können die Leistung des Modells durch Skalierung, Kreuzvalidierung und Optimierung der Hyperparameter verbessern. 

Naive Bayes Klassifikator mit Darlehensdatensatz

Lass uns den Naive Bayes Classifier mit dem echten Datensatz trainieren. Wir werden die meisten Aufgaben wiederholen, mit Ausnahme der Vorverarbeitung und der Datenexploration. 

Daten laden

In diesem Beispiel laden wir Darlehensdaten aus DataLab mit der Pandas-Funktion "read_csv". 

import pandas as pd


df = pd.read_csv('loan_data.csv')
df.head()

Datenexploration

Um mehr über den Datensatz zu erfahren, verwenden wir `.info()`.

• Der Datensatz besteht aus 14 Spalten und 9578 Zeilen.
• Abgesehen von "Zweck" sind die Spalten entweder Fließkommazahlen oder ganze Zahlen. 
• Unsere Zielspalte ist "nicht.vollständig.bezahlt". 

df.info()

RangeIndex: 9578 entries, 0 to 9577
Data columns (total 14 columns):
#   Column             Non-Null Count  Dtype 
---  ------             --------------  ----- 
0   credit.policy      9578 non-null   int64 
1   purpose            9578 non-null   object
2   int.rate           9578 non-null   float64
3   installment        9578 non-null   float64
4   log.annual.inc     9578 non-null   float64
5   dti                9578 non-null   float64
6   fico               9578 non-null   int64 
7   days.with.cr.line  9578 non-null   float64
8   revol.bal          9578 non-null   int64 
9   revol.util         9578 non-null   float64
10  inq.last.6mths     9578 non-null   int64 
11  delinq.2yrs        9578 non-null   int64 
12  pub.rec            9578 non-null   int64 
13  not.fully.paid     9578 non-null   int64 
dtypes: float64(6), int64(7), object(1)
memory usage: 1.0+ MB

In diesem Beispiel werden wir ein Modell entwickeln, um die Kunden vorherzusagen, die den Kredit nicht vollständig zurückgezahlt haben. Erforschen wir den Zweck und die Zielspalte, indem wir den Countplot von Seaborn verwenden. 

import seaborn as sns
import matplotlib.pyplot as plt

sns.countplot(data=df,x='purpose',hue='not.fully.paid')
plt.xticks(rotation=45, ha='right');

Unser Datensatz ist ein Ungleichgewicht, das die Leistung des Modells beeinträchtigt. Im Tutorial Resample an Imbalanced Dataset kannst du praktische Erfahrungen im Umgang mit unausgewogenen Datensätzen sammeln.

Datenverarbeitung 

Jetzt wandeln wir die Spalte "Zweck" mit der Pandas-Funktion "get_dummies" von kategorisch in ganzzahlig um.

pre_df = pd.get_dummies(df,columns=['purpose'],drop_first=True)
pre_df.head()

Danach definieren wir Merkmals- (X) und Zielvariablen (y) und teilen den Datensatz in Trainings- und Testdatensätze auf. 

from sklearn.model_selection import train_test_split

X = pre_df.drop('not.fully.paid', axis=1)
y = pre_df['not.fully.paid']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.33, random_state=125
)

Modellbau und Ausbildung

Modellbau und Ausbildung sind ganz einfach. Wir werden ein Modell auf einem Trainingsdatensatz mit Standard-Hyperparametern trainieren. 

from sklearn.naive_bayes import GaussianNB

model = GaussianNB()

model.fit(X_train, y_train);

Modellbewertung

Wir verwenden die Genauigkeit und den f1-Score, um die Leistung des Modells zu bestimmen, und es sieht so aus, als ob der Gauß-Naive-Bayes-Algorithmus recht gut abgeschnitten hat. 

from sklearn.metrics import (
    accuracy_score,
    confusion_matrix,
    ConfusionMatrixDisplay,
    f1_score,
    classification_report,
)

y_pred = model.predict(X_test)

accuray = accuracy_score(y_pred, y_test)
f1 = f1_score(y_pred, y_test, average="weighted")

print("Accuracy:", accuray)
print("F1 Score:", f1)

Accuracy: 0.8206263840556786
F1 Score: 0.8686606980013266

Aufgrund der Unausgewogenheit der Daten können wir sehen, dass die Konfusionsmatrix eine andere Geschichte erzählt. Bei einem Minderheitenziel: "nicht vollständig bezahlt", haben wir mehr falsch etikettiert. 

labels = ["Fully Paid", "Not fully Paid"]
cm = confusion_matrix(y_test, y_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=labels)
disp.plot();

Wenn du Probleme beim Training oder bei der Modellbewertung hast, kannst du dir das Naive Bayes Classification Tutorial mit dem Scikit-learn DataLab Workbook ansehen. Es wird mit einem Datensatz, Quellcode und Ausgaben geliefert. 

Null-Wahrscheinlichkeits-Problem

Angenommen, es gibt kein Tupel für einen risikobehafteten Kredit im Datensatz. In diesem Fall ist die Nachhersagewahrscheinlichkeit gleich null und das Modell kann keine Vorhersage treffen. Dieses Problem wird als Null-Wahrscheinlichkeit bezeichnet, weil die Wahrscheinlichkeit, dass eine bestimmte Klasse vorkommt, gleich Null ist.

Die Lösung für ein solches Problem ist die Laplacian-Korrektur oder Laplace-Transformation. Die Laplacian-Korrektur ist eine der Glättungsmethoden. Hier kannst du davon ausgehen, dass der Datensatz so groß ist, dass das Hinzufügen einer Zeile pro Klasse keinen Unterschied in der geschätzten Wahrscheinlichkeit macht. Damit wird das Problem der Wahrscheinlichkeitswerte auf Null gelöst.

Zum Beispiel: Nehmen wir an, dass es für die Klasse Kredit riskant 1000 Trainingstupel in der Datenbank gibt. In dieser Datenbank hat die Spalte Einkommen 0 Tupel für niedriges Einkommen, 990 Tupel für mittleres Einkommen und 10 Tupel für hohes Einkommen. Die Wahrscheinlichkeiten dieser Ereignisse, ohne die Laplacian-Korrektur, sind 0, 0,990 (von 990/1000) und 0,010 (von 10/1000)

Wende nun die Laplacian-Korrektur auf den gegebenen Datensatz an. Fügen wir für jedes Einkommens-Wert-Paar 1 weiteres Tupel hinzu. Die Wahrscheinlichkeiten für diese Ereignisse:

Vorteile

• Es ist nicht nur ein einfacher Ansatz, sondern auch eine schnelle und genaue Methode zur Vorhersage.
• Naive Bayes hat einen sehr geringen Rechenaufwand.
• Es kann effizient mit einem großen Datensatz arbeiten.
• Sie schneidet bei diskreten Antwortvariablen besser ab als bei kontinuierlichen Variablen.
• Sie kann bei Vorhersageproblemen mit mehreren Klassen eingesetzt werden.
• Auch bei Textanalyse-Problemen schneidet sie gut ab.
• Wenn die Annahme der Unabhängigkeit gilt, schneidet ein Naive Bayes-Klassifikator im Vergleich zu anderen Modellen wie der logistischen Regression besser ab.

Benachteiligungen

• Die Annahme von unabhängigen Merkmalen. In der Praxis ist es fast unmöglich, dass ein Modell eine Reihe von Prädiktoren erhält, die völlig unabhängig sind.
• Wenn es kein Trainingstupel einer bestimmten Klasse gibt, ist die Nachwahrscheinlichkeit gleich null. In diesem Fall ist das Modell nicht in der Lage, Vorhersagen zu treffen. Dieses Problem ist als Null-Wahrscheinlichkeit/Häufigkeitsproblem bekannt.

Fazit

Glückwunsch, du hast es bis zum Ende dieses Tutorials geschafft!

In diesem Tutorium hast du etwas über den Naive Bayes-Algorithmus, seine Funktionsweise, die Naive Bayes-Annahme, Probleme, Implementierung, Vorteile und Nachteile gelernt. Auf dem Weg dorthin hast du auch die Modellerstellung und -auswertung in scikit-learn für binäre und multinomiale Klassen gelernt.

Naive Bayes ist der einfachste und leistungsfähigste Algorithmus. Trotz der großen Fortschritte, die das maschinelle Lernen in den letzten Jahren gemacht hat, hat es sich bewährt. Sie wurde bereits in vielen Anwendungen erfolgreich eingesetzt, von der Textanalyse bis zu Empfehlungsmaschinen.

Wenn du mehr über scikit-learn in Python erfahren möchtest, besuche unseren Kurs Supervised Learning with scikit-learn und schau dir unser Scikit-Learn Tutorial an: Baseball Analytics Pt 1.