Bernoulli Naive Bayes, erklärt: Eine visuelle Anleitung mit Codebeispielen für Anfänger | von Samy Baladram | August 2024

Vorhersagekraft durch Ja/Nein-Wahrscheinlichkeit freisetzen

Im Gegensatz zum Basisansatz von Dummy-Klassifikatoren oder die Ähnlichkeitsbasiertes Denken von KNNNaive Bayes nutzt die Wahrscheinlichkeitstheorie. Es kombiniert die einzelnen Wahrscheinlichkeiten jedes „Hinweises“ (oder Merkmals), um eine endgültige Vorhersage zu treffen. Diese einfache, aber leistungsstarke Methode hat sich in verschiedenen Anwendungen des maschinellen Lernens als unschätzbar wertvoll erwiesen.

Naive Bayes ist ein maschineller Lernalgorithmus, der Wahrscheinlichkeit zur Klassifizierung von Daten verwendet. Er basiert auf Satz von Bayeseine Formel zur Berechnung bedingter Wahrscheinlichkeiten. Der „naive“ Teil bezieht sich auf die Kernannahme: Sie behandelt alle Merkmale als unabhängig voneinander, selbst wenn dies in Wirklichkeit nicht der Fall sein könnte. Diese Vereinfachung ist zwar oft unrealistisch, reduziert aber die Rechenkomplexität erheblich und funktioniert in vielen praktischen Szenarien intestine.

Es gibt drei Haupttypen von Naive-Bayes-Klassifikatoren. Der Hauptunterschied zwischen diesen Typen liegt in den Annahmen, die sie über die Verteilung der Merkmale treffen:

1. Bernoulli Naive Bayes: Geeignet für binäre/boolesche Merkmale. Es wird angenommen, dass jedes Merkmal eine binärwertige (0/1) Variable ist.
2. Multinomiale Naive Bayes: Wird normalerweise für diskrete Zählungen verwendet. Wird häufig bei der Textklassifizierung verwendet, wo Funktionen Wortanzahlen sein können.
3. Gaußscher naiver Bayes-Algorithmus: Nimmt an, dass kontinuierliche Merkmale einer Normalverteilung folgen.

Es ist ein guter Anfang, sich auf die einfachste zu konzentrieren, nämlich Bernoulli NB. Das „Bernoulli“ in seinem Namen kommt von der Annahme, dass jedes Merkmal binärwertig ist.

In diesem Artikel verwenden wir diesen künstlichen Golfdatensatz (inspiriert von (1)) als Beispiel. Dieser Datensatz sagt basierend auf den Wetterbedingungen voraus, ob eine Individual Golf spielen wird.

# IMPORTING DATASET #
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import pandas as pd
import numpy as np
dataset_dict = {
'Outlook': ('sunny', 'sunny', 'overcast', 'rain', 'rain', 'rain', 'overcast', 'sunny', 'sunny', 'rain', 'sunny', 'overcast', 'overcast', 'rain', 'sunny', 'overcast', 'rain', 'sunny', 'sunny', 'rain', 'overcast', 'rain', 'sunny', 'overcast', 'sunny', 'overcast', 'rain', 'overcast'),
'Temperature': (85.0, 80.0, 83.0, 70.0, 68.0, 65.0, 64.0, 72.0, 69.0, 75.0, 75.0, 72.0, 81.0, 71.0, 81.0, 74.0, 76.0, 78.0, 82.0, 67.0, 85.0, 73.0, 88.0, 77.0, 79.0, 80.0, 66.0, 84.0),
'Humidity': (85.0, 90.0, 78.0, 96.0, 80.0, 70.0, 65.0, 95.0, 70.0, 80.0, 70.0, 90.0, 75.0, 80.0, 88.0, 92.0, 85.0, 75.0, 92.0, 90.0, 85.0, 88.0, 65.0, 70.0, 60.0, 95.0, 70.0, 78.0),
'Wind': (False, True, False, False, False, True, True, False, False, False, True, True, False, True, True, False, False, True, False, True, True, False, True, False, False, True, False, False),
'Play': ('No', 'No', 'Sure', 'Sure', 'Sure', 'No', 'Sure', 'No', 'Sure', 'Sure', 'Sure', 'Sure', 'Sure', 'No', 'No', 'Sure', 'Sure', 'No', 'No', 'No', 'Sure', 'Sure', 'Sure', 'Sure', 'Sure', 'Sure', 'No', 'Sure')
}
df = pd.DataFrame(dataset_dict)
# ONE-HOT ENCODE 'Outlook' COLUMN
df = pd.get_dummies(df, columns=('Outlook'),  prefix='', prefix_sep='', dtype=int)
# CONVERT 'Windy' (bool) and 'Play' (binary) COLUMNS TO BINARY INDICATORS
df('Wind') = df('Wind').astype(int)
df('Play') = (df('Play') == 'Sure').astype(int)
# Set function matrix X and goal vector y
X, y = df.drop(columns='Play'), df('Play')
# Cut up the info into coaching and testing units
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.5, shuffle=False)
print(pd.concat((X_train, y_train), axis=1), finish='nn')
print(pd.concat((X_test, y_test), axis=1))

Wir werden es leicht für Bernoulli Naive Bayes anpassen, indem wir unsere Merkmale ins Binärsystem umwandeln.

# One-hot encode the categorized columns and drop them after, however do it individually for coaching and take a look at units
# Outline classes for 'Temperature' and 'Humidity' for coaching set
X_train('Temperature') = pd.minimize(X_train('Temperature'), bins=(0, 80, 100), labels=('Heat', 'Sizzling'))
X_train('Humidity') = pd.minimize(X_train('Humidity'), bins=(0, 75, 100), labels=('Dry', 'Humid'))
# Equally, outline for the take a look at set
X_test('Temperature') = pd.minimize(X_test('Temperature'), bins=(0, 80, 100), labels=('Heat', 'Sizzling'))
X_test('Humidity') = pd.minimize(X_test('Humidity'), bins=(0, 75, 100), labels=('Dry', 'Humid'))
# One-hot encode the categorized columns
one_hot_columns_train = pd.get_dummies(X_train(('Temperature', 'Humidity')), drop_first=True, dtype=int)
one_hot_columns_test = pd.get_dummies(X_test(('Temperature', 'Humidity')), drop_first=True, dtype=int)
# Drop the categorized columns from coaching and take a look at units
X_train = X_train.drop(('Temperature', 'Humidity'), axis=1)
X_test = X_test.drop(('Temperature', 'Humidity'), axis=1)
# Concatenate the one-hot encoded columns with the unique DataFrames
X_train = pd.concat((one_hot_columns_train, X_train), axis=1)
X_test = pd.concat((one_hot_columns_test, X_test), axis=1)
print(pd.concat((X_train, y_train), axis=1), 'n')
print(pd.concat((X_test, y_test), axis=1))

Bernoulli Naive Bayes arbeitet mit Daten, bei denen jedes Merkmal entweder 0 oder 1 ist.

1. Berechnen Sie die Wahrscheinlichkeit jeder Klasse in den Trainingsdaten.
2. Berechnen Sie für jedes Merkmal und jede Klasse die Wahrscheinlichkeit, dass das Merkmal bei einer gegebenen Klasse 1 bzw. 0 ist.
3. Für eine neue Instanz: Multiplizieren Sie für jede Klasse ihre Wahrscheinlichkeit mit der Wahrscheinlichkeit jedes Merkmalswerts (0 oder 1) für diese Klasse.
4. Sagen Sie die Klasse mit der höchsten resultierenden Wahrscheinlichkeit voraus.

Der Trainingsprozess für Bernoulli Naive Bayes umfasst die Berechnung von Wahrscheinlichkeiten aus den Trainingsdaten:

1. Berechnung der Klassenwahrscheinlichkeit: Berechnen Sie für jede Klasse ihre Wahrscheinlichkeit: (Anzahl der Instanzen in dieser Klasse) / (Gesamtzahl der Instanzen)

from fractions import Fraction
def calc_target_prob(attr):
total_counts = attr.value_counts().sum()
prob_series = attr.value_counts().apply(lambda x: Fraction(x, total_counts).limit_denominator())
return prob_series
print(calc_target_prob(y_train))

2.Berechnung der Merkmalswahrscheinlichkeit: Berechnen Sie für jedes Characteristic und jede Klasse:

• (Anzahl der Instanzen, bei denen das Characteristic in dieser Klasse 0 ist) / (Anzahl der Instanzen in dieser Klasse)
• (Anzahl der Instanzen, bei denen das Characteristic in dieser Klasse 1 ist) / (Anzahl der Instanzen in dieser Klasse)

from fractions import Fraction
def sort_attr_label(attr, lbl):
return (pd.concat((attr, lbl), axis=1)
.sort_values((attr.identify, lbl.identify))
.reset_index()
.rename(columns={'index': 'ID'})
.set_index('ID'))
def calc_feature_prob(attr, lbl):
total_classes = lbl.value_counts()
counts = pd.crosstab(attr, lbl)
prob_df = counts.apply(lambda x: (Fraction(c, total_classes(x.identify)).limit_denominator() for c in x))
return prob_df
print(sort_attr_label(y_train, X_train('sunny')))
print(calc_feature_prob(X_train('sunny'), y_train))

for col in X_train.columns:
print(calc_feature_prob(X_train(col), y_train), "n")

3. Glättung (optionally available): Fügen Sie dem Zähler und Nenner jeder Wahrscheinlichkeitsberechnung einen kleinen Wert (normalerweise 1) hinzu, um Nullwahrscheinlichkeiten zu vermeiden

# In sklearn, all processes above is summarized on this 'match' methodology:
from sklearn.naive_bayes import BernoulliNB
nb_clf = BernoulliNB(alpha=1)
nb_clf.match(X_train, y_train)

4. Ergebnisse speichern: Speichern Sie alle berechneten Wahrscheinlichkeiten zur Verwendung während der Klassifizierung.

Gegeben sei eine neue Instanz mit Options, die entweder 0 oder 1 sind:

1. Wahrscheinlichkeitssammlung: Für jede mögliche Klasse:

• Beginnen Sie mit der Wahrscheinlichkeit des Auftretens dieser Klasse (Klassenwahrscheinlichkeit).
• Erfassen Sie für jedes Characteristic in der neuen Instanz die Wahrscheinlichkeit, dass dieses Characteristic für diese Klasse 0/1 ist.

2. Punkteberechnung und -vorhersage: Für jede Klasse:

• Multiplizieren Sie alle gesammelten Wahrscheinlichkeiten miteinander
• Das Ergebnis ist die Punktzahl für diese Klasse
• Die Klasse mit der höchsten Punktzahl ist die Vorhersage

y_pred = nb_clf.predict(X_test)
print(y_pred)

# Consider the classifier
print(f"Accuracy: {accuracy_score(y_test, y_pred)}")

Bernoulli Naive Bayes hat einige wichtige Parameter:

1. Alpha (α): Dies ist der Glättungsparameter. Er fügt jedem Merkmal eine kleine Zahl hinzu, um Nullwahrscheinlichkeiten zu vermeiden. Der Standardwert ist normalerweise 1,0 (Laplace-Glättung), wie zuvor gezeigt.
2. Binarisieren: Wenn Ihre Options nicht bereits binär sind, werden sie mit diesem Schwellenwert konvertiert. Jeder Wert über diesem Schwellenwert wird zu 1 und jeder Wert darunter zu 0.

3. Vorher anpassen: Ob Klassen-A-priori-Wahrscheinlichkeiten gelernt oder gleichmäßige A-priori-Wahrscheinlichkeiten (50/50) angenommen werden sollen.

Wie jeder Algorithmus im maschinellen Lernen hat auch Bernoulli Naive Bayes seine Stärken und Schwächen.

1. Einfachheit: Einfach umzusetzen und zu verstehen.
2. Effizienz: Schnelles Trainieren und Vorhersagen, funktioniert intestine mit großen Merkmalsräumen.
3. Leistung bei kleinen Datensätzen: Kann auch mit begrenzten Trainingsdaten gute Leistung erbringen.
4. Verarbeitet hochdimensionale Daten: Funktioniert intestine mit vielen Funktionen, insbesondere bei der Textklassifizierung.

1. Unabhängigkeitsannahme: Nimmt an, dass alle Options unabhängig sind, was bei realen Daten oft nicht zutrifft.
2. Beschränkt auf binäre Funktionen: Funktioniert in seiner reinen Kind nur mit Binärdaten.
3. Sensibilität der Eingabedaten: Kann darauf reagieren, wie die Options binärisiert werden.
4. Nullfrequenzproblem: Ohne Glättung können Nullwahrscheinlichkeiten die Vorhersagen stark beeinflussen.

Der Bernoulli Naive Bayes-Klassifikator ist ein einfacher, aber leistungsstarker maschineller Lernalgorithmus für die binäre Klassifizierung. Er eignet sich hervorragend für die Textanalyse und Spam-Erkennung, bei denen die Merkmale normalerweise binär sind. Dieses für seine Geschwindigkeit und Effizienz bekannte probabilistische Modell eignet sich intestine für kleine Datensätze und hochdimensionale Räume.

Trotz seiner naiven Annahme der Merkmalsunabhängigkeit kann es hinsichtlich der Genauigkeit oft mit komplexeren Modellen mithalten. Bernoulli Naive Bayes dient als hervorragendes Foundation- und Echtzeit-Klassifizierungstool.

# Import wanted libraries
import pandas as pd
from sklearn.naive_bayes import BernoulliNB
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
# Load the dataset
dataset_dict = {
'Outlook': ('sunny', 'sunny', 'overcast', 'wet', 'wet', 'wet', 'overcast', 'sunny', 'sunny', 'wet', 'sunny', 'overcast', 'overcast', 'wet', 'sunny', 'overcast', 'wet', 'sunny', 'sunny', 'wet', 'overcast', 'wet', 'sunny', 'overcast', 'sunny', 'overcast', 'wet', 'overcast'),
'Temperature': (85.0, 80.0, 83.0, 70.0, 68.0, 65.0, 64.0, 72.0, 69.0, 75.0, 75.0, 72.0, 81.0, 71.0, 81.0, 74.0, 76.0, 78.0, 82.0, 67.0, 85.0, 73.0, 88.0, 77.0, 79.0, 80.0, 66.0, 84.0),
'Humidity': (85.0, 90.0, 78.0, 96.0, 80.0, 70.0, 65.0, 95.0, 70.0, 80.0, 70.0, 90.0, 75.0, 80.0, 88.0, 92.0, 85.0, 75.0, 92.0, 90.0, 85.0, 88.0, 65.0, 70.0, 60.0, 95.0, 70.0, 78.0),
'Wind': (False, True, False, False, False, True, True, False, False, False, True, True, False, True, True, False, False, True, False, True, True, False, True, False, False, True, False, False),
'Play': ('No', 'No', 'Sure', 'Sure', 'Sure', 'No', 'Sure', 'No', 'Sure', 'Sure', 'Sure', 'Sure', 'Sure', 'No', 'No', 'Sure', 'Sure', 'No', 'No', 'No', 'Sure', 'Sure', 'Sure', 'Sure', 'Sure', 'Sure', 'No', 'Sure')
}
df = pd.DataFrame(dataset_dict)
# Put together knowledge for mannequin
df = pd.get_dummies(df, columns=('Outlook'),  prefix='', prefix_sep='', dtype=int)
df('Wind') = df('Wind').astype(int)
df('Play') = (df('Play') == 'Sure').astype(int)
# Cut up knowledge into coaching and testing units
X, y = df.drop(columns='Play'), df('Play')
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.5, shuffle=False)
# Scale numerical options (for automated binarization)
scaler = StandardScaler()
float_cols = X_train.select_dtypes(embody=('float64')).columns
X_train(float_cols) = scaler.fit_transform(X_train(float_cols))
X_test(float_cols) = scaler.remodel(X_test(float_cols))
# Practice the mannequin
nb_clf = BernoulliNB()
nb_clf.match(X_train, y_train)
# Make predictions
y_pred = nb_clf.predict(X_test)
# Examine accuracy
print(f"Accuracy: {accuracy_score(y_test, y_pred)}")