Klassifizierungsalgorithmen - Logistische Regression
Einführung in die logistische Regression
Die logistische Regression ist ein überwachter Lernklassifizierungsalgorithmus, mit dem die Wahrscheinlichkeit einer Zielvariablen vorhergesagt wird. Die Art des Ziels oder der abhängigen Variablen ist dichotom, was bedeutet, dass es nur zwei mögliche Klassen gibt.
Mit einfachen Worten, die abhängige Variable ist binärer Natur, wobei die Daten entweder als 1 (steht für Erfolg / Ja) oder 0 (steht für Fehler / Nein) codiert sind.
Mathematisch gesehen sagt ein logistisches Regressionsmodell P (Y = 1) als Funktion von X voraus. Es ist einer der einfachsten ML-Algorithmen, die für verschiedene Klassifizierungsprobleme wie Spam-Erkennung, Diabetes-Vorhersage, Krebserkennung usw. verwendet werden können.
Arten der logistischen Regression
Im Allgemeinen bedeutet logistische Regression eine binäre logistische Regression mit binären Zielvariablen, es können jedoch zwei weitere Kategorien von Zielvariablen vorhergesagt werden. Basierend auf dieser Anzahl von Kategorien kann die logistische Regression in folgende Typen unterteilt werden:
Binär oder Binomial
Bei einer solchen Klassifizierung hat eine abhängige Variable nur zwei mögliche Typen, entweder 1 und 0. Beispielsweise können diese Variablen Erfolg oder Misserfolg darstellen, ja oder nein, Gewinn oder Verlust usw.
Multinomial
Bei einer solchen Klassifizierung kann eine abhängige Variable drei oder mehr mögliche ungeordnete Typen oder Typen ohne quantitative Signifikanz aufweisen. Diese Variablen können beispielsweise "Typ A" oder "Typ B" oder "Typ C" darstellen.
Ordinal
Bei einer solchen Klassifizierung kann eine abhängige Variable drei oder mehr mögliche geordnete Typen oder Typen mit quantitativer Bedeutung haben. Zum Beispiel können diese Variablen "schlecht" oder "gut", "sehr gut", "ausgezeichnet" darstellen und jede Kategorie kann die Werte 0,1,2,3 haben.
Annahmen zur logistischen Regression
Bevor wir uns mit der Implementierung der logistischen Regression befassen, müssen wir uns der folgenden Annahmen bewusst sein:
Bei einer binären logistischen Regression müssen die Zielvariablen immer binär sein und das gewünschte Ergebnis wird durch die Faktorstufe 1 dargestellt.
Das Modell sollte keine Multikollinearität aufweisen, dh die unabhängigen Variablen müssen unabhängig voneinander sein.
Wir müssen sinnvolle Variablen in unser Modell aufnehmen.
Wir sollten eine große Stichprobengröße für die logistische Regression wählen.
Modell der binären logistischen Regression
Die einfachste Form der logistischen Regression ist die binäre oder binomiale logistische Regression, bei der das Ziel oder die abhängige Variable nur zwei mögliche Typen haben kann, entweder 1 oder 0. Sie ermöglicht es uns, eine Beziehung zwischen mehreren Prädiktorvariablen und einer binären / binomialen Zielvariablen zu modellieren. Im Falle einer logistischen Regression wird die lineare Funktion grundsätzlich als Eingabe für eine andere Funktion verwendet, wie in der folgenden Beziehung:
$$ h _ {\ theta} {(x)} = g (\ theta ^ {T} x) ℎ 0 ≤ h _ {\ theta} ≤ 1 $$Hier ist die logistische oder Sigmoid-Funktion, die wie folgt angegeben werden kann:
$$ g (z) = \ frac {1} {1 + e ^ {- z}} ℎ = \ theta ^ {T} $$Die Sigmoidkurve kann mit Hilfe des folgenden Diagramms dargestellt werden. Wir können sehen, dass die Werte der y-Achse zwischen 0 und 1 liegen und die Achse bei 0,5 kreuzen.
Die Klassen können in positive oder negative unterteilt werden. Die Ausgabe fällt unter die Wahrscheinlichkeit einer positiven Klasse, wenn sie zwischen 0 und 1 liegt. Für unsere Implementierung interpretieren wir die Ausgabe der Hypothesenfunktion als positiv, wenn sie ≥ 0,5 ist, andernfalls negativ.
Wir müssen auch eine Verlustfunktion definieren, um zu messen, wie gut der Algorithmus unter Verwendung der Gewichte für Funktionen funktioniert, die durch Theta wie folgt dargestellt werden:
ℎ = ()
$$ J (\ theta) = \ frac {1} {m}. (- y ^ {T} log (h) - (1 -y) ^ Tlog (1-h)) $$Nachdem wir die Verlustfunktion definiert haben, besteht unser Hauptziel darin, die Verlustfunktion zu minimieren. Dies kann mit Hilfe der Anpassung der Gewichte erfolgen, dh durch Erhöhen oder Verringern der Gewichte. Mit Hilfe von Ableitungen der Verlustfunktion für jedes Gewicht könnten wir wissen, welche Parameter ein hohes Gewicht und welche ein geringeres Gewicht haben sollten.
Die folgende Gradientenabstiegsgleichung zeigt uns, wie sich der Verlust ändern würde, wenn wir die Parameter ändern würden -
$$ \ frac {()} {\ theta_ {j}} = \ frac {1} {m} X ^ {T} (() -) $$Implementierung in Python
Jetzt werden wir das obige Konzept der binomialen logistischen Regression in Python implementieren. Zu diesem Zweck verwenden wir einen multivariaten Blumendatensatz mit dem Namen "Iris", der 3 Klassen mit jeweils 50 Instanzen enthält. Wir werden jedoch die ersten beiden Feature-Spalten verwenden. Jede Klasse repräsentiert eine Art Irisblume.
Zuerst müssen wir die erforderlichen Bibliotheken wie folgt importieren:
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import datasetsLaden Sie als Nächstes den Iris-Datensatz wie folgt:
iris = datasets.load_iris()
X = iris.data[:, :2]
y = (iris.target != 0) * 1Wir können unsere Trainingsdaten wie folgt zeichnen:
plt.figure(figsize=(6, 6))
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='g', label='0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='y', label='1')
plt.legend();
Als nächstes definieren wir die Sigmoidfunktion, die Verlustfunktion und den Gradientenabstieg wie folgt:
class LogisticRegression:
def __init__(self, lr=0.01, num_iter=100000, fit_intercept=True, verbose=False):
self.lr = lr
self.num_iter = num_iter
self.fit_intercept = fit_intercept
self.verbose = verbose
def __add_intercept(self, X):
intercept = np.ones((X.shape[0], 1))
return np.concatenate((intercept, X), axis=1)
def __sigmoid(self, z):
return 1 / (1 + np.exp(-z))
def __loss(self, h, y):
return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()
def fit(self, X, y):
if self.fit_intercept:
X = self.__add_intercept(X)Initialisieren Sie nun die Gewichte wie folgt:
self.theta = np.zeros(X.shape[1])
for i in range(self.num_iter):
z = np.dot(X, self.theta)
h = self.__sigmoid(z)
gradient = np.dot(X.T, (h - y)) / y.size
self.theta -= self.lr * gradient
z = np.dot(X, self.theta)
h = self.__sigmoid(z)
loss = self.__loss(h, y)
if(self.verbose ==True and i % 10000 == 0):
print(f'loss: {loss} \t')Mit Hilfe des folgenden Skripts können wir die Ausgabewahrscheinlichkeiten vorhersagen -
def predict_prob(self, X):
if self.fit_intercept:
X = self.__add_intercept(X)
return self.__sigmoid(np.dot(X, self.theta))
def predict(self, X):
return self.predict_prob(X).round()Als nächstes können wir das Modell bewerten und wie folgt darstellen:
model = LogisticRegression(lr=0.1, num_iter=300000)
preds = model.predict(X)
(preds == y).mean()
plt.figure(figsize=(10, 6))
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='g', label='0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='y', label='1')
plt.legend()
x1_min, x1_max = X[:,0].min(), X[:,0].max(),
x2_min, x2_max = X[:,1].min(), X[:,1].max(),
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))
grid = np.c_[xx1.ravel(), xx2.ravel()]
probs = model.predict_prob(grid).reshape(xx1.shape)
plt.contour(xx1, xx2, probs, [0.5], linewidths=1, colors='red');
Multinomiales logistisches Regressionsmodell
Eine andere nützliche Form der logistischen Regression ist die multinomiale logistische Regression, bei der das Ziel oder die abhängige Variable drei oder mehr mögliche ungeordnete Typen haben kann, dh die Typen ohne quantitative Signifikanz.
Implementierung in Python
Jetzt werden wir das obige Konzept der multinomialen logistischen Regression in Python implementieren. Zu diesem Zweck verwenden wir einen Datensatz von sklearn mit dem Namen digit.
Zuerst müssen wir die erforderlichen Bibliotheken wie folgt importieren:
Import sklearn
from sklearn import datasets
from sklearn import linear_model
from sklearn import metrics
from sklearn.model_selection import train_test_splitAls nächstes müssen wir den Ziffern-Datensatz laden -
digits = datasets.load_digits()Definieren Sie nun die Merkmalsmatrix (X) und den Antwortvektor (y) wie folgt:
X = digits.data
y = digits.targetMit Hilfe der nächsten Codezeile können wir X und Y in Trainings- und Testsätze aufteilen -
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=1)Erstellen Sie nun ein Objekt der logistischen Regression wie folgt:
digreg = linear_model.LogisticRegression()Jetzt müssen wir das Modell mithilfe der folgenden Trainingssätze trainieren:
digreg.fit(X_train, y_train)Machen Sie als nächstes die Vorhersagen für den Testsatz wie folgt:
y_pred = digreg.predict(X_test)Als nächstes drucken Sie die Genauigkeit des Modells wie folgt:
print("Accuracy of Logistic Regression model is:",
metrics.accuracy_score(y_test, y_pred)*100)Ausgabe
Accuracy of Logistic Regression model is: 95.6884561891516Aus der obigen Ausgabe können wir ersehen, dass die Genauigkeit unseres Modells bei 96 Prozent liegt.