Einführung in den Naive Bayes-Algorithmus

Aktualisiert auf November 15, 2024 5 Minuten gelesen

Tisch:

• Einführung

• Bedingte Wahrscheinlichkeit

• Naive-Bayes-Klassifikation

• Vorteile und Einschränkungen dieses Algorithmus

• Übung

• Lösung

Einführung

Naive Bayes ist ein Klassifizierungsalgorithmus für maschinelles Lernen, der auf dem Bayes-Theorem basiert. Es ist sehr effizient, insbesondere beim Umgang mit Textdaten wie Stimmungsanalyse, Spam-Erkennung und Textklassifizierung.

Dieser Algorithmus wird „naiv“ genannt, da davon ausgegangen wird, dass alle Datensatzvariablen unabhängig sind, was nicht immer der Fall ist.

Bevor wir weiter erklären, wie Naive Bayes funktioniert, stellen wir sicher, dass wir Folgendes verstehen:

Bedingte Wahrscheinlichkeit

Der Naive-Bayes-Algorithmus basiert auf dem Bayes-Theorem, das auf der bedingten Wahrscheinlichkeit basiert: Es handelt sich um die Wahrscheinlichkeit des Eintretens eines Ereignisses A unter der Voraussetzung, dass ein Ereignis B bereits eingetreten ist.

Beispiel:

Nehmen wir zwei Gläser mit farbigen Kugeln:

• Glas 1 enthält 3 blaue Kugeln, 2 rote Kugeln und 4 grüne Kugeln.

• Glas 2 enthält 1 blaue Kugel, 4 rote Kugeln und 3 grüne Kugeln.

Wir wollen die Wahrscheinlichkeit berechnen, zufällig eine blaue Kugel aus einem der Gläser auszuwählen

Es ist nichts anderes als die Summe der Wahrscheinlichkeiten, eine blaue Kugel aus Jar1 oder Jar2 auszuwählen.

Nun wollen wir die Wahrscheinlichkeit berechnen, eine blaue Kugel auszuwählen, vorausgesetzt, wir haben Jar1 ausgewählt:

Schließlich möchten wir die Wahrscheinlichkeit berechnen, Jar1 auszuwählen, vorausgesetzt, wir haben eine blaue Kugel gezogen. Hier verwenden wir das Bayes-Theorem, das wie folgt lautet:

Naive Bayes-Klassifizierung

Im Naive Bayes-Klassifikator möchten wir die Klasse finden, die die bedingte Wahrscheinlichkeit bei gegebenem Eingabevektor X maximiert. Somit kann Naive Bayes wie folgt formuliert werden:

Unter Verwendung des Bayes-Theorems wird die Funktion zu:

In dieser Formulierung ist es einfach, P(Ci) zu berechnen, das nichts anderes als die Wahrscheinlichkeit der Klasse Ci ist, und es ist einfach, P(x) zu berechnen, das die Wahrscheinlichkeit des Auftretens des Ereignisses x ist.

Was schwer zu berechnen ist, ist P(x|Ci); die Wahrscheinlichkeit des Ereignisses x bei gegebener Klasse Ci. Um dies weiter zu vereinfachen, müssen wir annehmen, dass alle Eingabevariablen unabhängig sind; somit können wir schreiben:

Aufgrund dieser Annahme bezeichnen wir diesen Klassifikator tatsächlich als „naiv“, da wir die Unabhängigkeit der Eingabevariablen nicht immer garantieren können. Der Naive-Bayes-Klassifikator wird zu:

Tatsächlich können wir diese Formulierung noch weiter vereinfachen, indem wir P(x) eliminieren, da sie für alle Klassen gleich ist:

Schauen wir uns nun ein Beispiel an:

| Wetter | Zeit | Wochentag | Abendessen |

| ------- | -------- | --------------- | ------ |

| Klar | Abend | Wochenende | Köche |

| Bewölkt | Nacht | Wochentag | Bestellungen |

| Regnerisch | Nacht | Wochentag | Bestellungen |

| Regnerisch | Mittag | Wochentag | Bestellungen |

| Bewölkt | Mittag | Wochenende | Köche |

| Klar | Nacht | Wochenende | Köche |

| Verschneit | Abend | Wochenende | Bestellungen |

| Klar | Nacht | Wochentag | Köche |

| Klar | Mitternacht | Wochenende | Bestellungen |

Hier haben wir einen kleinen Datensatz, der drei Eingabevariablen enthält: Wetter, Uhrzeit und Wochentag sowie eine Zielvariable: „Abendessen“, die angibt, ob eine Person ihr Abendessen kocht oder bestellt. Wir möchten die Klasse der Eingabe x={Clear, Evening, Weekend} finden:

Wir müssen die bedingte Wahrscheinlichkeit für die Klasse „Köche“ und die Klasse „Bestellungen“ anhand der Eingabe x={Klar, Abend, Wochenende} berechnen. Die vorhergesagte Klasse ist diejenige mit der höchsten bedingten Wahrscheinlichkeit.

Wir beginnen mit der Berechnung der bedingten Wahrscheinlichkeit der Klasse „Köche“:

Jetzt berechnen wir jede bedingte Wahrscheinlichkeit einzeln:

Die Wahrscheinlichkeit von „Weather=“Clear“, wenn die Klasse „Cooks“ ist, ist die Anzahl der Zeilen mit dem Wetter „Clear“ und der Klasse „Cooks“ im Vergleich zur Gesamtzahl der Zeilen mit der Klasse „Cooks“.

Das Gleiche gilt für die anderen bedingten Wahrscheinlichkeiten:

Bei der Wahrscheinlichkeit P(Cooks) handelt es sich nun um die Anzahl der Zeilen mit der Klasse „Cooks“ über die Gesamtzahl der Zeilen:

Nun berechnen wir das Produkt dieser Wahrscheinlichkeiten:

Das war für die Klasse „Köche“, jetzt müssen wir dasselbe für die Klasse „Bestellungen“ tun:

Wir berechnen die einzelnen Wahrscheinlichkeiten:

Und schließlich berechnen wir das Produkt der Wahrscheinlichkeiten:

Schließlich nehmen wir die Klasse mit der höchsten Wahrscheinlichkeit, nämlich die Klasse „Köche“:

Vorteile und Einschränkungen dieses Algorithmus

Vorteile:

• Es ist ein sehr schneller Klassifikator.

• Es ist einfach umzusetzen.

• Es gibt keine Trainingsphase, sondern nur eine Schlussfolgerung.

• Es sind nicht viele Daten erforderlich, um Rückschlüsse zu ziehen.

Einschränkungen:

• Naive Bayes geht davon aus, dass die Eingabevariablen unabhängig sind, was nicht immer zutrifft.

• Naive Bayes leidet unter dem Nullhäufigkeitsproblem: Es entsteht, wenn einer Eingabevariablen eine Wahrscheinlichkeit von Null zugewiesen wird. Dadurch wird die gesamte bedingte Wahrscheinlichkeit P(C|x) auf Null gesetzt. Ein Trick, um dies zu vermeiden, besteht darin, für alle Variablen eine Mindesthäufigkeit von 1 (anstelle von 0) zu verwenden.

Übung

Hier ist der Datenrahmen desselben Datensatzes, den wir im Beispiel gesehen haben.

Ihre Aufgabe ist es, Naive Bayes selbst mit Python zu implementieren:

import pandas as pd
dataset = pd.DataFrame()
dataset['Weather'] = ['Clear', 'Cloudy', 'Rainy', 'Rainy', 'Cloudy', 'Clear', 'Snowy', 'Clear', 'Clear']
dataset['Time'] = ['Evening', 'Night', 'Night', 'Midday', 'Midday', 'Night', 'Evening', 'Night', 'Midnight']
dataset['Day'] = ['Weekend', 'Weekday', 'Weekday', 'Weekday', 'Weekend', 'Weekend', 'Weekend', 'Weekday', 'Weekend']
dataset['Class'] = ['Cooks', 'Orders', 'Orders', 'Orders', 'Cooks', 'Cooks', 'Orders', 'Cooks', 'Orders']

def naive_bayes(weather, time, day):

# res_dict = {class1: probability of class 1, class1: probability of class 1
return res_dict

Lösung

def naive_bayes(x_weather, x_time, x_day):
  TARGET = 'Dinner' # The name of the target variable
  CLASSES = list(dataset['Dinner'].unique()) # The classes of the target variable
len_dataset = len(dataset) # The length of the dataset
res_dict = {} # res_dict = {class1:probability1, ..., class_n:probability_n}

# for each class of the target classes, we calculate the it's conditional probability
for class_name in CLASSES:
# the number of lines that belong to the class "class_name"
len_c  = len(dataset[ (dataset[TARGET] == class_name) ])

# the number of lines that belong to the class "class_name" and have weather="x_weather"
n_weather = len(dataset[ (dataset[TARGET] == class_name) & (dataset['Weather'] == x_weather) ])
# the number of lines that belong to the class "class_name" and have time="x_time"
n_time = len(dataset[ (dataset[TARGET] == class_name) & (dataset['Time'] == x_time) ])

# the number of lines that belong to the class "class_name" and have day="x_day"
n_day  = len(dataset[ (dataset[TARGET] == class_name) & (dataset['Day'] == x_day) ])

# We calculate the conditional probability:
# P(class|x) = P(weather|class) x P(time|class) x P(day|class) x P(class)
p = (n_weather / len_c) * (n_time / len_c) * (n_day / len_c) * (len_c / len_dataset)        res_dict[class_name] = p
return res_dict

Master Data Science und KI mit Code Labs Academy! Nehmen Sie an unserem Online-Bootcamp teil – Flexible Teilzeit- und Vollzeitoptionen verfügbar.