Klassifizierung - Einführung

Einführung in die Klassifizierung

Die Klassifizierung kann als der Prozess der Vorhersage der Klasse oder Kategorie aus beobachteten Werten oder gegebenen Datenpunkten definiert werden. Die kategorisierte Ausgabe kann die Form "Schwarz" oder "Weiß" oder "Spam" oder "Kein Spam" haben.

Mathematisch gesehen ist die Klassifizierung die Aufgabe, eine Abbildungsfunktion (f) von Eingabevariablen (X) an Ausgabevariablen (Y) zu approximieren. Es gehört grundsätzlich zum überwachten maschinellen Lernen, bei dem neben dem Eingabedatensatz auch Ziele bereitgestellt werden.

Ein Beispiel für ein Klassifizierungsproblem kann die Spam-Erkennung in E-Mails sein. Es kann nur zwei Kategorien von Ausgaben geben: "Spam" und "kein Spam". Daher ist dies eine binäre Typklassifizierung.

Um diese Klassifizierung zu implementieren, müssen wir zuerst den Klassifizierer trainieren. In diesem Beispiel werden "Spam" - und "kein Spam" -E-Mails als Trainingsdaten verwendet. Nachdem der Klassifikator erfolgreich trainiert wurde, kann er zum Erkennen einer unbekannten E-Mail verwendet werden.

Arten von Lernenden in der Klassifikation

Wir haben zwei Arten von Lernenden in Bezug auf Klassifizierungsprobleme -

Faule Lernende

Wie der Name schon sagt, warten solche Lernenden darauf, dass die Testdaten nach dem Speichern der Trainingsdaten angezeigt werden. Die Klassifizierung erfolgt erst nach Erhalt der Testdaten. Sie verbringen weniger Zeit mit Training, aber mehr Zeit mit Vorhersagen. Beispiele für faule Lernende sind K-nächster Nachbar und fallbasiertes Denken.

Eifrige Lernende

Im Gegensatz zu faulen Lernenden erstellen eifrige Lernende ein Klassifizierungsmodell, ohne darauf zu warten, dass die Testdaten nach dem Speichern der Trainingsdaten angezeigt werden. Sie verbringen mehr Zeit mit Training, aber weniger Zeit mit Vorhersagen. Beispiele für eifrige Lernende sind Entscheidungsbäume, naive Bayes und künstliche neuronale Netze (ANN).

Erstellen eines Klassifikators in Python

Scikit-learn, eine Python-Bibliothek für maschinelles Lernen, kann verwendet werden, um einen Klassifikator in Python zu erstellen. Die Schritte zum Erstellen eines Klassifikators in Python lauten wie folgt:

Schritt 1: Importieren des erforderlichen Python-Pakets

Um einen Klassifikator mit scikit-learn zu erstellen, müssen wir ihn importieren. Wir können es mit folgendem Skript importieren -

import sklearn

Schritt 2: Datensatz importieren

Nach dem Import des erforderlichen Pakets benötigen wir einen Datensatz, um ein Klassifizierungsvorhersagemodell zu erstellen. Wir können es aus dem sklearn-Dataset importieren oder ein anderes gemäß unseren Anforderungen verwenden. Wir werden die Breast Cancer Wisconsin Diagnostic Database von sklearn verwenden. Wir können es mit Hilfe des folgenden Skripts importieren -

from sklearn.datasets import load_breast_cancer

Das folgende Skript lädt den Datensatz.

data = load_breast_cancer()

Wir müssen auch die Daten organisieren und dies kann mit Hilfe der folgenden Skripte erfolgen -

label_names = data['target_names']
   labels = data['target']
   feature_names = data['feature_names']
   features = data['data']

Der folgende Befehl gibt den Namen der Etiketten aus: 'malignant' und 'benign'im Falle unserer Datenbank.

print(label_names)

Die Ausgabe des obigen Befehls sind die Namen der Beschriftungen -

['malignant' 'benign']

Diese Beschriftungen werden den Binärwerten 0 und 1 zugeordnet. Malignant Krebs wird durch 0 und dargestellt Benign Krebs wird durch 1 dargestellt.

Die Feature-Namen und Feature-Werte dieser Beschriftungen können mithilfe der folgenden Befehle angezeigt werden:

print(feature_names[0])

Die Ausgabe des obigen Befehls sind die Namen der Merkmale für die Bezeichnung 0, d. H. Malignant Krebs -

mean radius

In ähnlicher Weise können Namen der Merkmale für das Etikett wie folgt erzeugt werden:

print(feature_names[1])

Die Ausgabe des obigen Befehls sind die Namen der Merkmale für Label 1, d. H. Benign Krebs -

mean texture

Wir können die Funktionen für diese Etiketten mit Hilfe des folgenden Befehls drucken:

print(features[0])

Dies ergibt die folgende Ausgabe -

[
   1.799e+01 1.038e+01 1.228e+02 1.001e+03 1.184e-01 2.776e-01 3.001e-01
   1.471e-01 2.419e-01 7.871e-02 1.095e+00 9.053e-01 8.589e+00 1.534e+02
   6.399e-03 4.904e-02 5.373e-02 1.587e-02 3.003e-02 6.193e-03 2.538e+01
   1.733e+01 1.846e+02 2.019e+03 1.622e-01 6.656e-01 7.119e-01 2.654e-01
   4.601e-01 1.189e-01
]

Wir können die Funktionen für diese Etiketten mit Hilfe des folgenden Befehls drucken:

print(features[1])

Dies ergibt die folgende Ausgabe -

[
   2.057e+01 1.777e+01 1.329e+02 1.326e+03 8.474e-02 7.864e-02 8.690e-02
   7.017e-02 1.812e-01 5.667e-02 5.435e-01 7.339e-01 3.398e+00 7.408e+01
   5.225e-03 1.308e-02 1.860e-02 1.340e-02 1.389e-02 3.532e-03 2.499e+01
   2.341e+01 1.588e+02 1.956e+03 1.238e-01 1.866e-01 2.416e-01 1.860e-01
   2.750e-01 8.902e-02
]

Schritt 3: Organisieren von Daten in Trainings- und Testsätzen

Da wir unser Modell an unsichtbaren Daten testen müssen, werden wir unseren Datensatz in zwei Teile aufteilen: einen Trainingssatz und einen Testsatz. Wir können die Funktion train_test_split () des sklearn-Python-Pakets verwenden, um die Daten in Mengen aufzuteilen. Der folgende Befehl importiert die Funktion -

from sklearn.model_selection import train_test_split

Mit dem nächsten Befehl werden die Daten in Trainings- und Testdaten aufgeteilt. In diesem Beispiel verwenden wir 40 Prozent der Daten zu Testzwecken und 60 Prozent der Daten zu Schulungszwecken.

train, test, train_labels, test_labels = train_test_split(
   features,labels,test_size = 0.40, random_state = 42
)

Schritt 4: Modellbewertung

Nachdem wir die Daten in Training und Test unterteilt haben, müssen wir das Modell erstellen. Zu diesem Zweck verwenden wir den Naive Bayes-Algorithmus. Die folgenden Befehle importieren das GaussianNB-Modul -

from sklearn.naive_bayes import GaussianNB

Initialisieren Sie nun das Modell wie folgt:

gnb = GaussianNB()

Als nächstes können wir mit Hilfe des folgenden Befehls das Modell trainieren -

model = gnb.fit(train, train_labels)

Zu Bewertungszwecken müssen wir nun Vorhersagen treffen. Dies kann mithilfe der Funktion pred () wie folgt erfolgen:

preds = gnb.predict(test)
print(preds)

Dies ergibt die folgende Ausgabe -

[
   1 0 0 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0 1 1 1 1 1 1 0 1
   0 1 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 0 0 1 1 0 0 1 1 1 0 0 1 1 0 0 1 0 1 1
   1 1 1 1 0 1 1 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 0 1 1 0 1 1 0
   0 0 1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 0 1 0 1 1 0 1 0 0 1 1 1 1
   1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0 0 0 1 1 0 
   1 0 1 1 1 1 0 1 1 0 1 1 1 0 1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1 0 0 1 1 0 
   1

]

Die obigen Reihen von Nullen und Einsen in der Ausgabe sind die vorhergesagten Werte für die Malignant und Benign Tumorklassen.

Schritt 5: Finden der Genauigkeit

Wir können die Genauigkeit des im vorherigen Schritt erstellten Modells ermitteln, indem wir die beiden Arrays test_labels und preds vergleichen. Wir werden die Genauigkeit.score () -Funktion verwenden, um die Genauigkeit zu bestimmen.

from sklearn.metrics import accuracy_score
   print(accuracy_score(test_labels,preds))
   0.951754385965

Die obige Ausgabe zeigt, dass der NaïveBayes-Klassifikator zu 95,17% genau ist.

Bewertungsmetriken für die Klassifizierung

Die Aufgabe wird auch dann nicht erledigt, wenn Sie die Implementierung Ihrer Anwendung oder Ihres Modells für maschinelles Lernen abgeschlossen haben. Wir müssen herausfinden, wie effektiv unser Modell ist. Es kann verschiedene Bewertungsmetriken geben, aber wir müssen sie sorgfältig auswählen, da die Auswahl der Metriken Einfluss darauf hat, wie die Leistung eines Algorithmus für maschinelles Lernen gemessen und verglichen wird.

Im Folgenden finden Sie einige wichtige Bewertungsmetriken für die Klassifizierung, aus denen Sie basierend auf Ihrem Datensatz und der Art des Problems auswählen können:

Verwirrung Matrix

Dies ist der einfachste Weg, um die Leistung eines Klassifizierungsproblems zu messen, bei dem die Ausgabe aus zwei oder mehr Klassentypen bestehen kann. Eine Verwirrungsmatrix ist nichts anderes als eine Tabelle mit zwei Dimensionen, nämlich. "Ist" und "Vorausgesagt" und außerdem haben beide Dimensionen "True Positives (TP)", "True Negatives (TN)", "False Positives (FP)", "False Negatives (FN)", wie unten gezeigt -

Die Erklärung der mit der Verwirrungsmatrix verbundenen Begriffe lautet wie folgt:

True Positives (TP) - Dies ist der Fall, wenn sowohl die tatsächliche Klasse als auch die vorhergesagte Klasse des Datenpunkts 1 ist.
True Negatives (TN) - Dies ist der Fall, wenn sowohl die tatsächliche Klasse als auch die vorhergesagte Klasse des Datenpunkts 0 sind.
False Positives (FP) - Dies ist der Fall, wenn die tatsächliche Datenpunktklasse 0 und die vorhergesagte Datenpunktklasse 1 ist.
False Negatives (FN) - Dies ist der Fall, wenn die tatsächliche Datenpunktklasse 1 und die vorhergesagte Datenpunktklasse 0 ist.

Wir können die Verwirrungsmatrix mit Hilfe der Funktion confusion_matrix () von sklearn finden. Mit Hilfe des folgenden Skripts können wir die Verwirrungsmatrix des oben erstellten binären Klassifikators finden -

from sklearn.metrics import confusion_matrix

Ausgabe

[
   [ 73   7]
   [  4 144]
]

Richtigkeit

Es kann als die Anzahl der korrekten Vorhersagen definiert werden, die von unserem ML-Modell gemacht werden. Wir können es leicht durch Verwirrungsmatrix mit Hilfe der folgenden Formel berechnen -

$$ = \ frac {+} {+++} $$

Für den oben erstellten binären Klassifikator ist TP + TN = 73 + 144 = 217 und TP + FP + FN + TN = 73 + 7 + 4 + 144 = 228.

Daher ist Genauigkeit = 217/228 = 0,951754385965, was dasselbe ist, das wir nach dem Erstellen unseres binären Klassifikators berechnet haben.

Präzision

Präzision, die beim Abrufen von Dokumenten verwendet wird, kann als die Anzahl der korrekten Dokumente definiert werden, die von unserem ML-Modell zurückgegeben werden. Wir können es leicht durch Verwirrungsmatrix mit Hilfe der folgenden Formel berechnen -

$$ = \ frac {} {+ FP} $$

Für den oben erstellten binären Klassifikator ist TP = 73 und TP + FP = 73 + 7 = 80.

Daher ist Präzision = 73/80 = 0,915

Rückruf oder Empfindlichkeit

Der Rückruf kann als die Anzahl der von unserem ML-Modell zurückgegebenen Positiven definiert werden. Wir können es leicht durch Verwirrungsmatrix mit Hilfe der folgenden Formel berechnen -

$$ = \ frac {} {+ FN} $$

Für den oben erstellten binären Klassifikator ist TP = 73 und TP + FN = 73 + 4 = 77.

Daher ist Präzision = 73/77 = 0,94805

Spezifität

Die Spezifität kann im Gegensatz zum Rückruf als die Anzahl der von unserem ML-Modell zurückgegebenen Negative definiert werden. Wir können es leicht durch Verwirrungsmatrix mit Hilfe der folgenden Formel berechnen -

$$ = \ frac {N} {N + FP} $$

Für den oben erstellten binären Klassifikator ist TN = 144 und TN + FP = 144 + 7 = 151.

Daher ist Präzision = 144/151 = 0,95364