KLASSIFIZIERUNGSALGORITHMUS

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}")

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)}")