Gaußsche Naive Bayes, erklärt: Ein visueller Leitfaden mit Codebeispielen für Anfänger | von Samy Baladram | Okt. 2024

KLASSIFIZIERUNGSALGORITHMUS

Glockenförmige Annahmen für bessere Vorhersagen

Aufbauend auf unserem vorherigen Artikel über Bernoulli Naive Bayesdas Binärdaten verarbeitet, untersuchen wir nun Gaussian Naive Bayes für kontinuierliche Daten. Im Gegensatz zum binären Ansatz geht dieser Algorithmus davon aus, dass jedes Merkmal einer Normalverteilung (Gaußverteilung) folgt.

Hier werden wir sehen, wie Gaussian Naive Bayes mit kontinuierlichen, glockenförmigen Daten umgeht und genaue Vorhersagen liefert ohne in die komplizierte Mathematik einzusteigen des Satzes von Bayes.

Wie andere Naive-Bayes-Varianten geht Gaussian Naive Bayes von der „naiven“ Annahme der Merkmalsunabhängigkeit aus. Es wird davon ausgegangen, dass die Options angesichts der Klassenbezeichnung bedingt unabhängig sind.

Während Bernoulli Naive Bayes jedoch für Datensätze mit binären Merkmalen geeignet ist, geht Gaußian Naive Bayes davon aus, dass die Merkmale folgen eine kontinuierliche Normale (Gaussian) Verteilung. Auch wenn diese Annahme in der Realität nicht immer zutrifft, vereinfacht sie die Berechnungen und führt oft zu überraschend genauen Ergebnissen.

In diesem Artikel verwenden wir diesen künstlichen Golfdatensatz (vom Autor erstellt) als Beispiel. Dieser Datensatz sagt anhand der 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 = {
'Rainfall': (0.0, 2.0, 7.0, 18.0, 3.0, 3.0, 0.0, 1.0, 0.0, 25.0, 0.0, 18.0, 9.0, 5.0, 0.0, 1.0, 7.0, 0.0, 0.0, 7.0, 5.0, 3.0, 0.0, 2.0, 0.0, 8.0, 4.0, 4.0),
'Temperature': (29.4, 26.7, 28.3, 21.1, 20.0, 18.3, 17.8, 22.2, 20.6, 23.9, 23.9, 22.2, 27.2, 21.7, 27.2, 23.3, 24.4, 25.6, 27.8, 19.4, 29.4, 22.8, 31.1, 25.0, 26.1, 26.7, 18.9, 28.9),
'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),
'WindSpeed': (2.1, 21.2, 1.5, 3.3, 2.0, 17.4, 14.9, 6.9, 2.7, 1.6, 30.3, 10.9, 3.0, 7.5, 10.3, 3.0, 3.9, 21.9, 2.6, 17.3, 9.6, 1.9, 16.0, 4.6, 3.2, 8.3, 3.2, 2.2),
'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)
# Set characteristic matrix X and goal vector y
X, y = df.drop(columns='Play'), df('Play')
# Break up the information 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))

Gaussian Naive Bayes arbeitet mit kontinuierlichen Daten und geht davon aus, dass jedes Merkmal einer Gaußschen (Regular-)Verteilung folgt.

1. Berechnen Sie die Wahrscheinlichkeit jeder Klasse in den Trainingsdaten.
2. Schätzen Sie für jedes Merkmal und jede Klasse den Mittelwert und die Varianz der Merkmalswerte innerhalb dieser Klasse.
3. Für eine neue Instanz:
   A. Berechnen Sie für jede Klasse die Wahrscheinlichkeitsdichtefunktion (PDF) jedes Merkmalswerts unter der Gaußschen Verteilung dieses Merkmals innerhalb der Klasse.
   B. Multiplizieren Sie die Klassenwahrscheinlichkeit mit dem Produkt der PDF-Werte für alle Options.
4. Sagen Sie die Klasse mit der höchsten resultierenden Wahrscheinlichkeit voraus.

Transformieren nicht-gaußscher verteilter Daten

Denken Sie daran, dass dieser Algorithmus naiv davon ausgeht, dass alle Eingabemerkmale eine Gauß-/Normalverteilung aufweisen?

Da wir uns über die Verteilung unserer Daten nicht wirklich sicher sind, insbesondere bei Merkmalen, die eindeutig keiner Gaußschen Verteilung folgen, wenden wir a an Machttransformation (wie Field-Cox) vor der Verwendung von Gaussian Naive Bayes kann von Vorteil sein. Dieser Ansatz kann dazu beitragen, die Daten gaußähnlicher zu machen, was besser mit den Annahmen des Algorithmus übereinstimmt.

from sklearn.preprocessing import PowerTransformer
# Initialize and match the PowerTransformer
pt = PowerTransformer(standardize=True) # Commonplace Scaling already included
X_train_transformed = pt.fit_transform(X_train)
X_test_transformed = pt.rework(X_test)

Jetzt sind wir bereit für das Coaching.

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. Characteristic-Wahrscheinlichkeitsberechnung : Berechnen Sie für jedes Merkmal und jede Klasse den Mittelwert (μ) und die Standardabweichung (σ) der Merkmalswerte innerhalb dieser Klasse anhand der Trainingsdaten. Berechnen Sie dann die Wahrscheinlichkeit mithilfe der Gaußschen Wahrscheinlichkeitsdichtefunktion (PDF)-Formel.

def calculate_class_probabilities(X_train_transformed, y_train, feature_names):
courses = y_train.distinctive()
equations = pd.DataFrame(index=courses, columns=feature_names)
for cls in courses:
X_class = X_train_transformed(y_train == cls)
imply = X_class.imply(axis=0)
std = X_class.std(axis=0)
k1 = 1 / (std * np.sqrt(2 * np.pi))
k2 = 2 * (std ** 2)
for i, column in enumerate(feature_names):
equation = f"{k1(i):.3f}·exp(-(x-({imply(i):.2f}))²/{k2(i):.3f})"
equations.loc(cls, column) = equation
return equations
# Use the operate with the reworked coaching knowledge
equation_table = calculate_class_probabilities(X_train_transformed, y_train, X.columns)
# Show the equation desk
print(equation_table)

3. Glätten: Gaussian Naive Bayes verwendet einen einzigartigen Glättungsansatz. Im Gegensatz zur Laplace-Glättung in anderen Variantenfügt es allen Varianzen einen winzigen Wert (0,000000001-mal die größte Varianz) hinzu. Dies verhindert numerische Instabilität durch Division durch Null oder sehr kleine Zahlen.

Gegeben eine neue Instanz mit kontinuierlichen Funktionen:

1. Wahrscheinlichkeitssammlung:
Für jede mögliche Klasse:
· Beginnen Sie mit der Wahrscheinlichkeit des Auftretens dieser Klasse (Klassenwahrscheinlichkeit).
· Berechnen Sie für jedes Characteristic in der neuen Instanz die Wahrscheinlichkeitsdichtefunktion dieses Options innerhalb der Klasse.

2. Punkteberechnung und -vorhersage:
Für jede Klasse:
· Multiplizieren Sie alle gesammelten PDF-Werte miteinander.
· Das Ergebnis ist die Punktzahl für diese Klasse.
· Die Klasse mit der höchsten Punktzahl ist die Vorhersage.

from scipy.stats import norm
def calculate_class_probability_products(X_train_transformed, y_train, X_new, feature_names, target_name):
courses = y_train.distinctive()
n_features = X_train_transformed.form(1)
# Create column names utilizing precise characteristic names
column_names = (target_name) + listing(feature_names) + ('Product')
probability_products = pd.DataFrame(index=courses, columns=column_names)
for cls in courses:
X_class = X_train_transformed(y_train == cls)
imply = X_class.imply(axis=0)
std = X_class.std(axis=0)
prior_prob = np.imply(y_train == cls)
probability_products.loc(cls, target_name) = prior_prob
feature_probs = ()
for i, characteristic in enumerate(feature_names):
prob = norm.pdf(X_new(0, i), imply(i), std(i))
probability_products.loc(cls, characteristic) = prob
feature_probs.append(prob)
product = prior_prob * np.prod(feature_probs)
probability_products.loc(cls, 'Product') = product
return probability_products
# Assuming X_new is your new pattern reshaped to (1, n_features)
X_new = np.array((-1.28, 1.115, 0.84, 0.68)).reshape(1, -1)
# Calculate likelihood merchandise
prob_products = calculate_class_probability_products(X_train_transformed, y_train, X_new, X.columns, y.title)
# Show the likelihood product desk
print(prob_products)

from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score
# Initialize and prepare the Gaussian Naive Bayes mannequin
gnb = GaussianNB()
gnb.match(X_train_transformed, y_train)
# Make predictions on the take a look at set
y_pred = gnb.predict(X_test_transformed)
# Calculate the accuracy
accuracy = accuracy_score(y_test, y_pred)
# Print the accuracy
print(f"Accuracy: {accuracy:.4f}")

GaussianNB ist für seine Einfachheit und Wirksamkeit bekannt. Das Wichtigste, was Sie bei seinen Parametern beachten sollten, ist:

1. Prioren: Dies ist der bemerkenswerteste Parameter, ähnlich wie Bernoulli Naive Bayes. In den meisten Fällen müssen Sie es nicht manuell festlegen. Standardmäßig wird es aus Ihren Trainingsdaten berechnet, was oft intestine funktioniert.
2. var_smoothing: Dies ist ein Stabilitätsparameter, den Sie selten anpassen müssen. (Der Standardwert ist 0,000000001)

Die wichtigste Erkenntnis ist, dass dieser Algorithmus so konzipiert ist, dass er sofort funktioniert. In den meisten Situationen können Sie es verwenden, ohne sich Gedanken über die Parameterabstimmung machen zu müssen.

Vorteile:

1. Einfachheit: Behält die einfach zu implementierende und verständliche Eigenschaft bei.
2. Effizienz: Bleibt beim Coaching und bei der Vorhersage schnell und eignet sich daher für umfangreiche Anwendungen mit kontinuierlichen Funktionen.
3. Flexibilität mit Daten: Bewältigt sowohl kleine als auch große Datensätze intestine und passt sich dem Umfang des jeweiligen Issues an.
4. Kontinuierliches Characteristic-Dealing with: Gedeiht mit kontinuierlichen und realwertigen Options und eignet sich daher excellent für Aufgaben wie die Vorhersage realwertiger Ausgaben oder die Arbeit mit Daten, bei denen Options auf einem Kontinuum variieren.

Nachteile:

1. Unabhängigkeitsannahme: Geht immer noch davon aus, dass Options angesichts der Klasse bedingt unabhängig sind, was möglicherweise nicht in allen realen Szenarien zutrifft.
2. Annahme der Gaußschen Verteilung: Funktioniert am besten, wenn Merkmalswerte tatsächlich einer Normalverteilung folgen. Nicht-Normalverteilungen können zu einer suboptimalen Leistung führen (können jedoch mit der von uns besprochenen Energy Transformation behoben werden).
3. Empfindlichkeit gegenüber Ausreißern: Kann durch Ausreißer in den Trainingsdaten erheblich beeinträchtigt werden, da sie die Mittelwert- und Varianzberechnungen verzerren.

Gaussian Naive Bayes ist ein effizienter Klassifikator für eine Vielzahl von Anwendungen mit kontinuierlichen Daten. Seine Fähigkeit, realwertige Funktionen zu verarbeiten, reicht über die Verwendung binärer Klassifizierungsaufgaben hinaus und macht es zu einer ersten Wahl für zahlreiche Anwendungen.

Es werden zwar einige Annahmen über Daten getroffen (Merkmalsunabhängigkeit und Normalverteilung), aber wenn diese Bedingungen erfüllt sind, bietet es eine robuste Leistung, was es aufgrund seines Gleichgewichts zwischen Einfachheit und Leistungsfähigkeit sowohl bei Anfängern als auch bei erfahrenen Datenwissenschaftlern zu einem Favoriten macht.

import pandas as pd
from sklearn.naive_bayes import GaussianNB
from sklearn.preprocessing import PowerTransformer
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
# Load the dataset
dataset_dict = {
'Rainfall': (0.0, 2.0, 7.0, 18.0, 3.0, 3.0, 0.0, 1.0, 0.0, 25.0, 0.0, 18.0, 9.0, 5.0, 0.0, 1.0, 7.0, 0.0, 0.0, 7.0, 5.0, 3.0, 0.0, 2.0, 0.0, 8.0, 4.0, 4.0),
'Temperature': (29.4, 26.7, 28.3, 21.1, 20.0, 18.3, 17.8, 22.2, 20.6, 23.9, 23.9, 22.2, 27.2, 21.7, 27.2, 23.3, 24.4, 25.6, 27.8, 19.4, 29.4, 22.8, 31.1, 25.0, 26.1, 26.7, 18.9, 28.9),
'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),
'WindSpeed': (2.1, 21.2, 1.5, 3.3, 2.0, 17.4, 14.9, 6.9, 2.7, 1.6, 30.3, 10.9, 3.0, 7.5, 10.3, 3.0, 3.9, 21.9, 2.6, 17.3, 9.6, 1.9, 16.0, 4.6, 3.2, 8.3, 3.2, 2.2),
'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
X, y = df.drop('Play', axis=1), (df('Play') == 'Sure').astype(int)
# Break up knowledge into coaching and testing units
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, shuffle=False)
# Apply PowerTransformer
pt = PowerTransformer(standardize=True)
X_train_transformed = pt.fit_transform(X_train)
X_test_transformed = pt.rework(X_test)
# Prepare the mannequin
nb_clf = GaussianNB()
nb_clf.match(X_train_transformed, y_train)
# Make predictions
y_pred = nb_clf.predict(X_test_transformed)
# Verify accuracy
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.4f}")