Naiver Bayes-Algorithmus…. Naiver Bayes-Klassifikator-Algorithmus | von Aftabahamedbaig | Juli 2023

• Der Naive-Bayes-Algorithmus ist ein überwachter Lernalgorithmus, der auf basiert Satz von Bayes und zur Lösung von Klassifizierungsproblemen verwendet.
• Es wird hauptsächlich verwendet in Textklassifizierung Dazu gehört ein hochdimensionaler Trainingsdatensatz.
• Der Naive Bayes Classifier ist einer der einfachsten und effektivsten Klassifizierungsalgorithmen, der beim Aufbau schneller Modelle für maschinelles Lernen hilft, die schnelle Vorhersagen treffen können.
• Es handelt sich um einen probabilistischen Klassifikator, das heißt, er prognostiziert auf der Grundlage der Wahrscheinlichkeit eines Objekts.
• Einige beliebte Beispiele für den Naiven Bayes-Algorithmus sind: Spam-Filterung, sentimentale Analyse und Klassifizierung von Artikeln.

Der Naive-Bayes-Algorithmus besteht aus den beiden Wörtern Naive und Bayes, die wie folgt beschrieben werden können:

• Naiv: Es wird als naiv bezeichnet, weil es davon ausgeht, dass das Auftreten eines bestimmten Merkmals unabhängig vom Auftreten anderer Merkmale ist. Wenn die Frucht beispielsweise anhand von Farbe, Kind und Geschmack identifiziert wird, werden rote, kugelförmige und süße Früchte als Apfel erkannt. Daher trägt jedes Merkmal einzeln dazu bei, zu erkennen, dass es sich um einen Apfel handelt, ohne voneinander abhängig zu sein.
• Bayes: Es wird Bayes genannt, weil es auf dem Prinzip von basiert Satz von Bayes.

• Der Satz von Bayes ist auch bekannt als Bayes-Regel oder Bayes’sches Gesetz, die dazu dient, die Wahrscheinlichkeit einer Hypothese mit Vorwissen zu bestimmen. Es kommt auf die bedingte Wahrscheinlichkeit an.
• Die Formel für den Satz von Bayes lautet:

Wo,

P(A|B) ist die Posterior-Wahrscheinlichkeit: Wahrscheinlichkeit der Hypothese A zum beobachteten Ereignis B.

P(B|A) ist die Chance-Wahrscheinlichkeit: Wahrscheinlichkeit des Beweises, vorausgesetzt, dass die Wahrscheinlichkeit einer Hypothese wahr ist.

P(A) ist die A-priori-Wahrscheinlichkeit: Wahrscheinlichkeit einer Hypothese vor Beobachtung der Beweise.

P(B) ist die Grenzwahrscheinlichkeit: Beweiswahrscheinlichkeit.

Die Funktionsweise des Naive-Bayes-Klassifikators lässt sich anhand des folgenden Beispiels verstehen:

Angenommen, wir haben einen Datensatz von Wetterverhältnisse und entsprechende Zielvariable „Spielen“. Anhand dieses Datensatzes müssen wir additionally entscheiden, ob wir an einem bestimmten Tag entsprechend den Wetterbedingungen spielen sollen oder nicht. Um dieses Downside zu lösen, müssen wir die folgenden Schritte ausführen:

1. Konvertieren Sie den angegebenen Datensatz in Häufigkeitstabellen.
2. Erstellen Sie eine Wahrscheinlichkeitstabelle, indem Sie die Wahrscheinlichkeiten bestimmter Merkmale ermitteln.
3. Verwenden Sie nun den Satz von Bayes, um die A-posteriori-Wahrscheinlichkeit zu berechnen.

Downside: Wenn das Wetter sonnig ist, sollte der Spieler dann spielen oder nicht?

Lösung: Um dieses Downside zu lösen, betrachten Sie zunächst den folgenden Datensatz:

Outlook Play 0 Regnerisch Ja 1 Sonnig Ja 2 Bewölkt Ja 3 Bewölkt Ja 4 Sunny Nr 5 Regnerisch Ja 6 Sonnig Ja 7 Bewölkt Ja 8 Regnerisch Nr 9 Sunny Nr 10 Sonnig Ja 11 Regnerisch Nr 12 Bewölkt Ja 13 Bewölkt Ja

Häufigkeitstabelle für die Wetterbedingungen:

Wetter Ja Nein Bewölkt 5 0 Regnerisch 2 2 Sonnig 3 2 Insgesamt 10 5

Wahrscheinlichkeitstabelle Wetterbedingungen:

Wetter Nein Ja Bewölkt 0 5 5/14= 0,35 Regnerisch 2 2 4/14=0,29 Sonnig 2 3 5/14=0,35 Alle 4/14=0,29 10/14=0,71

Anwendung des Bayes-Theorems:

P(Ja|Sonnig)= P(Sonnig|Ja)*P(Ja)/P(Sonnig)

P(Sonnig|Ja)= 3/10= 0,3

P(Sonnig)= 0,35

P(Ja)=0,71

Additionally P(Ja|Sonnig) = 0,3*0,71/0,35= 0,60

P(Nein|Sonnig)= P(Sonnig|Nein)*P(Nein)/P(Sonnig)

P(Sonnig|NEIN)= 2/4=0,5

P(Nein)= 0,29

P(Sonnig)= 0,35

Additionally P(Nein|Sonnig)= 0,5*0,29/0,35 = 0,41

Wie wir aus der obigen Berechnung sehen können P(Ja|Sonnig)>P(Nein|Sonnig)

Daher kann der Spieler das Spiel an einem sonnigen Tag spielen.

• Naive Bayes ist einer der schnellen und einfachen ML-Algorithmen zur Vorhersage einer Klasse von Datensätzen.
• Es kann sowohl für binäre als auch für mehrklassige Klassifizierungen verwendet werden.
• Im Vergleich zu den anderen Algorithmen schneidet es bei Mehrklassenvorhersagen intestine ab.
• Es ist die beliebteste Wahl für Probleme bei der Textklassifizierung.

• Naive Bayes geht davon aus, dass alle Merkmale unabhängig oder nicht miteinander verbunden sind, sodass die Beziehung zwischen Merkmalen nicht erlernt werden kann.

• Es wird genutzt für Kreditwürdigkeit.
• Es wird verwendet in Klassifizierung medizinischer Daten.
• Es kann in verwendet werden Echtzeitvorhersagen weil der Naive Bayes Classifier ein eifriger Lerner ist.
• Es wird bei der Textklassifizierung verwendet, z Spam-Filterung Und Stimmungsanalyse.

Es gibt drei Arten von Naive-Bayes-Modellen, die im Folgenden aufgeführt sind:

• Gauß: Das Gaußsche Modell geht davon aus, dass Merkmale einer Normalverteilung folgen. Das heißt, wenn Prädiktoren kontinuierliche statt diskrete Werte annehmen, geht das Modell davon aus, dass diese Werte aus der Gaußschen Verteilung entnommen werden.
• Multinomial: Der Multinomial Naive Bayes-Klassifikator wird verwendet, wenn die Daten multinomial verteilt sind. Es wird hauptsächlich für Probleme bei der Klassifizierung von Dokumenten verwendet. Es bedeutet, dass ein bestimmtes Dokument zu welcher Kategorie gehört, z. B. Sport, Politik, Bildung usw.
  Der Klassifikator verwendet die Häufigkeit von Wörtern für die Prädiktoren.
• Bernoulli: Der Bernoulli-Klassifikator funktioniert ähnlich wie der Multinomial-Klassifikator, aber die Prädiktorvariablen sind unabhängige boolesche Variablen. Beispielsweise ob ein bestimmtes Wort in einem Dokument vorhanden ist oder nicht. Dieses Modell ist auch für Dokumentenklassifizierungsaufgaben bekannt.

Jetzt werden wir einen Naive-Bayes-Algorithmus mit Python implementieren. Dafür verwenden wir additionally „Benutzerdaten” Datensatz, das wir in unserem anderen Klassifizierungsmodell verwendet haben. Daher können wir das Naive-Bayes-Modell problemlos mit den anderen Modellen vergleichen.

• Datenvorverarbeitungsschritt
• Anpassung von Naive Bayes an das Trainingsset
• Vorhersage des Testergebnisses
• Testgenauigkeit des Ergebnisses (Erstellung einer Verwirrungsmatrix)
• Visualisierung des Testsatzergebnisses.

In diesem Schritt werden wir die Daten vorverarbeiten/vorbereiten, damit wir sie effizient in unserem Code verwenden können. Es ist ähnlich wie bei uns Datenvorverarbeitung. Der Code hierfür ist unten angegeben:

1. Importieren der Bibliotheken
2. numpy als nm importieren
3. matplotlib.pyplot als mtp importieren
4. Pandas als PD importieren
5. # Importieren des Datensatzes
6. dataset = pd.read_csv(‚user_data.csv‘)
7. x = dataset.iloc[:, [2, 3]].Werte
8. y = dataset.iloc[:, 4].Werte
9. # Aufteilen des Datensatzes in den Trainingssatz und den Testsatz
10. aus sklearn.model_selection import train_test_split
11. x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0,25, random_state = 0)
12. # Funktionsskalierung
13. aus sklearn.preprocessing importieren Sie StandardScaler
14. sc = StandardScaler()
15. x_train = sc.fit_transform(x_train)
16. x_test = sc.remodel(x_test)

Im obigen Code haben wir den Datensatz mit „dataset = pd.read_csv(‚user_data.csv‘). Der geladene Datensatz wird in Trainings- und Testsatz unterteilt, und dann haben wir die Characteristic-Variable skaliert.

Die Ausgabe für den Datensatz ist wie folgt:

Nach dem Vorverarbeitungsschritt passen wir nun das Naive Bayes-Modell an den Trainingssatz an. Unten ist der Code dafür:

1. # Anpassung von Naive Bayes an das Trainingsset
2. aus sklearn.naive_bayes GaussianNB importieren
3. Klassifikator = GaussianNB()
4. classifier.match(x_train, y_train)

Im obigen Code haben wir verwendet Gaußscher NB-Klassifikator um es an den Trainingsdatensatz anzupassen. Wir können gemäß unseren Anforderungen auch andere Klassifikatoren verwenden.

Ausgang:

Out[6]: GaussianNB(priors=None, var_smoothing=1e-09)

Jetzt werden wir das Ergebnis des Testsatzes vorhersagen. Dazu erstellen wir eine neue Prädiktorvariable y_predund wird die Vorhersagefunktion verwenden, um die Vorhersagen zu treffen.

1. # Vorhersage der Testsatzergebnisse
2. y_pred = classifier.predict(x_test)

Ausgang:

Die obige Ausgabe zeigt das Ergebnis für den Vorhersagevektor y_pred und realer Vektor y_test. Wir können sehen, dass einige Vorhersagen von den tatsächlichen Werten abweichen, bei denen es sich um falsche Vorhersagen handelt.

Jetzt überprüfen wir die Genauigkeit des Naive Bayes-Klassifikators mithilfe der Verwirrungsmatrix. Unten ist der Code dafür:

1. # Erstellen der Verwirrungsmatrix
2. aus sklearn.metrics import context_matrix
3. cm = confusion_matrix(y_test, y_pred)

Ausgang:

Wie wir in der obigen Ausgabe der Verwirrungsmatrix sehen können, gibt es 7+3=10 falsche Vorhersagen und 65+25=90 richtige Vorhersagen.

Als nächstes visualisieren wir das Ergebnis des Trainingssatzes mit dem Naive Bayes Classifier. Unten ist der Code dafür:

1. # Visualisieren der Ergebnisse des Trainingssatzes
2. aus matplotlib.colours ListedColormap importieren
3. x_set, y_set = x_train, y_train
4. X1, X2 = nm.meshgrid(nm.arange(begin = x_set[:, 0].min() – 1, cease = x_set[:, 0].max() + 1, Schritt = 0,01),
5. nm.arange(begin = x_set[:, 1].min() – 1, cease = x_set[:, 1].max() + 1, Schritt = 0,01))
6. mtp.contourf(X1, X2, classifier.predict(nm.array([X1.ravel(), X2.ravel()]).T).reshape(X1.form),
7. alpha = 0,75, cmap = ListedColormap((‚lila‘, ‚grün‘)))
8. mtp.xlim(X1.min(), X1.max())
9. mtp.ylim(X2.min(), X2.max())
10. für i, j in enumerate(nm.distinctive(y_set)):
11. mtp.scatter(x_set[y_set == j, 0]x_set[y_set == j, 1],
12. c = ListedColormap((‚lila‘, ‚grün‘))(i), label = j)
13. mtp.title(‚Naive Bayes (Trainingssatz)‘)
14. mtp.xlabel(‚Alter‘)
15. mtp.ylabel(‚Geschätztes Gehalt‘)
16. mtp.legend()
17. mtp.present()

Ausgang:

In der obigen Ausgabe können wir sehen, dass der Naive-Bayes-Klassifikator die Datenpunkte mit der feinen Grenze getrennt hat. Es ist die Gaußsche Kurve, wie wir sie verwendet haben GaussianNB Klassifikator in unserem Code.

1. # Visualisierung der Testsatzergebnisse
2. aus matplotlib.colours ListedColormap importieren
3. x_set, y_set = x_test, y_test
4. X1, X2 = nm.meshgrid(nm.arange(begin = x_set[:, 0].min() – 1, cease = x_set[:, 0].max() + 1, Schritt = 0,01),
5. nm.arange(begin = x_set[:, 1].min() – 1, cease = x_set[:, 1].max() + 1, Schritt = 0,01))
6. mtp.contourf(X1, X2, classifier.predict(nm.array([X1.ravel(), X2.ravel()]).T).reshape(X1.form),
7. alpha = 0,75, cmap = ListedColormap((‚lila‘, ‚grün‘)))
8. mtp.xlim(X1.min(), X1.max())
9. mtp.ylim(X2.min(), X2.max())
10. für i, j in enumerate(nm.distinctive(y_set)):
11. mtp.scatter(x_set[y_set == j, 0]x_set[y_set == j, 1],
12. c = ListedColormap((‚lila‘, ‚grün‘))(i), label = j)
13. mtp.title(‚Naive Bayes (Testsatz)‘)
14. mtp.xlabel(‚Alter‘)
15. mtp.ylabel(‚Geschätztes Gehalt‘)
16. mtp.legend()
17. mtp.present()

Ausgang:

Die obige Ausgabe ist die endgültige Ausgabe für Testsatzdaten. Wie wir sehen können, hat der Klassifikator eine Gaußsche Kurve erstellt, um die „gekauften“ und „nicht gekauften“ Variablen zu unterteilen. Es gibt einige falsche Vorhersagen, die wir in der Verwirrungsmatrix berechnet haben. Aber es ist immer noch ein ziemlich guter Klassifikator.