Regressionsalgorithmen - Lineare Regression
Einführung in die lineare Regression
Die lineare Regression kann als das statistische Modell definiert werden, das die lineare Beziehung zwischen einer abhängigen Variablen und einem gegebenen Satz unabhängiger Variablen analysiert. Eine lineare Beziehung zwischen Variablen bedeutet, dass sich der Wert einer abhängigen Variablen entsprechend ändert (erhöht oder verringert), wenn sich der Wert einer oder mehrerer unabhängiger Variablen ändert (erhöht oder verringert).
Mathematisch kann die Beziehung mit Hilfe der folgenden Gleichung dargestellt werden:
Y = mX + b
Hier ist Y die abhängige Variable, die wir vorhersagen wollen
X ist die abhängige Variable, mit der wir Vorhersagen treffen.
m ist die Steigung der Regressionslinie, die den Effekt darstellt, den X auf Y hat
b ist eine Konstante, die als Y-Achsenabschnitt bekannt ist. Wenn X = 0 ist, wäre Y gleich b.
Darüber hinaus kann die lineare Beziehung positiver oder negativer Natur sein, wie nachstehend erläutert -
Positive lineare Beziehung
Eine lineare Beziehung wird als positiv bezeichnet, wenn sowohl die unabhängige als auch die abhängige Variable zunimmt. Es kann mit Hilfe der folgenden Grafik verstanden werden -
Negative lineare Beziehung
Eine lineare Beziehung wird als positiv bezeichnet, wenn unabhängige Erhöhungen und abhängige Variablen abnehmen. Es kann mit Hilfe der folgenden Grafik verstanden werden -
Arten der linearen Regression
Es gibt zwei Arten der linearen Regression:
- Einfache lineare Regression
- Multiple lineare Regression
Einfache lineare Regression (SLR)
Es ist die grundlegendste Version der linearen Regression, die eine Antwort unter Verwendung eines einzelnen Features vorhersagt. Die Annahme in SLR ist, dass die beiden Variablen linear zusammenhängen.
Python-Implementierung
Wir können SLR in Python auf zwei Arten implementieren: Die eine besteht darin, Ihr eigenes Dataset bereitzustellen, und die andere darin, das Dataset aus der Python-Bibliothek scikit-learn zu verwenden.
Example 1 - Im folgenden Python-Implementierungsbeispiel verwenden wir unseren eigenen Datensatz.
Zunächst importieren wir die erforderlichen Pakete wie folgt:
%matplotlib inline
import numpy as np
import matplotlib.pyplot as pltDefinieren Sie als Nächstes eine Funktion, die die wichtigen Werte für SLR berechnet -
def coef_estimation(x, y):Die folgende Skriptzeile gibt die Anzahl der Beobachtungen n - an.
n = np.size(x)Der Mittelwert des x- und y-Vektors kann wie folgt berechnet werden:
m_x, m_y = np.mean(x), np.mean(y)Wir können Kreuzabweichung und Abweichung um x wie folgt finden -
SS_xy = np.sum(y*x) - n*m_y*m_x
SS_xx = np.sum(x*x) - n*m_x*m_xAls nächstes können Regressionskoeffizienten, dh b, wie folgt berechnet werden:
b_1 = SS_xy / SS_xx
b_0 = m_y - b_1*m_x
return(b_0, b_1)Als nächstes müssen wir eine Funktion definieren, die die Regressionslinie darstellt und den Antwortvektor vorhersagt -
def plot_regression_line(x, y, b):In der folgenden Skriptzeile werden die tatsächlichen Punkte als Streudiagramm dargestellt.
plt.scatter(x, y, color = "m", marker = "o", s = 30)Die folgende Skriptzeile sagt den Antwortvektor voraus -
y_pred = b[0] + b[1]*xDie folgenden Skriptzeilen zeichnen die Regressionslinie und setzen die Beschriftungen darauf -
plt.plot(x, y_pred, color = "g")
plt.xlabel('x')
plt.ylabel('y')
plt.show()Zuletzt müssen wir die Funktion main () definieren, um einen Datensatz bereitzustellen und die oben definierte Funktion aufzurufen.
def main():
x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
y = np.array([100, 300, 350, 500, 750, 800, 850, 900, 1050, 1250])
b = coef_estimation(x, y)
print("Estimated coefficients:\nb_0 = {} \nb_1 = {}".format(b[0], b[1]))
plot_regression_line(x, y, b)
if __name__ == "__main__":
main()Ausgabe
Estimated coefficients:
b_0 = 154.5454545454545
b_1 = 117.87878787878788
Example 2 - Im folgenden Python-Implementierungsbeispiel verwenden wir den Diabetes-Datensatz von scikit-learn.
Zunächst importieren wir die erforderlichen Pakete wie folgt:
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model
from sklearn.metrics import mean_squared_error, r2_scoreAls nächstes laden wir den Diabetes-Datensatz und erstellen sein Objekt -
diabetes = datasets.load_diabetes()Während wir SLR implementieren, werden wir nur eine Funktion wie folgt verwenden:
X = diabetes.data[:, np.newaxis, 2]Als nächstes müssen wir die Daten wie folgt in Trainings- und Testsätze aufteilen:
X_train = X[:-30]
X_test = X[-30:]Als nächstes müssen wir das Ziel wie folgt in Trainings- und Testsätze aufteilen:
y_train = diabetes.target[:-30]
y_test = diabetes.target[-30:]Um das Modell zu trainieren, müssen wir nun ein lineares Regressionsobjekt wie folgt erstellen:
regr = linear_model.LinearRegression()Als nächstes trainieren Sie das Modell mit den Trainingssätzen wie folgt:
regr.fit(X_train, y_train)Machen Sie als Nächstes Vorhersagen mit dem Testsatz wie folgt:
y_pred = regr.predict(X_test)Als nächstes werden wir einige Koeffizienten wie MSE, Varianzbewertung usw. wie folgt drucken:
print('Coefficients: \n', regr.coef_)
print("Mean squared error: %.2f" % mean_squared_error(y_test, y_pred))
print('Variance score: %.2f' % r2_score(y_test, y_pred))Zeichnen Sie nun die Ausgaben wie folgt:
plt.scatter(X_test, y_test, color='blue')
plt.plot(X_test, y_pred, color='red', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()Ausgabe
Coefficients:
[941.43097333]
Mean squared error: 3035.06
Variance score: 0.41
Multiple lineare Regression (MLR)
Es ist die Erweiterung der einfachen linearen Regression, die eine Antwort unter Verwendung von zwei oder mehr Merkmalen vorhersagt. Mathematisch können wir es wie folgt erklären:
Betrachten Sie einen Datensatz mit n Beobachtungen, p Merkmalen, dh unabhängigen Variablen, und y als eine Antwort, dh abhängige Variable. Die Regressionslinie für p Merkmale kann wie folgt berechnet werden:
$$ h (x_ {i}) = b_ {0} + b_ {1} x_ {i1} + b_ {2} x_ {i2} + ... + b_ {p} x_ {ip} $$Hier ist h (x i ) der vorhergesagte Antwortwert und b 0 , b 1 , b 2 …, b p sind die Regressionskoeffizienten.
Modelle mit mehreren linearen Regressionen enthalten immer die Fehler in den Daten, die als Restfehler bezeichnet werden und die Berechnung wie folgt ändern:
$$ h (x_ {i}) = b_ {0} + b_ {1} x_ {i1} + b_ {2} x_ {i2} + ... + b_ {p} x_ {ip} + e_ {i} $$Wir können die obige Gleichung auch wie folgt schreiben:
$$ y_ {i} = h (x_ {i}) + e_ {i} \: oder \: e_ {i} = y_ {i} - h (x_ {i}) $$Python-Implementierung
In diesem Beispiel verwenden wir den Boston Housing-Datensatz von scikit learn -
Zunächst importieren wir die erforderlichen Pakete wie folgt:
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model, metricsLaden Sie als Nächstes den Datensatz wie folgt:
boston = datasets.load_boston(return_X_y=False)Die folgenden Skriptzeilen definieren die Merkmalsmatrix X und den Antwortvektor Y -
X = boston.data
y = boston.targetTeilen Sie den Datensatz anschließend wie folgt in Trainings- und Testsätze auf:
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.7, random_state=1)Beispiel
Erstellen Sie nun ein lineares Regressionsobjekt und trainieren Sie das Modell wie folgt:
reg = linear_model.LinearRegression()
reg.fit(X_train, y_train)
print('Coefficients: \n', reg.coef_)
print('Variance score: {}'.format(reg.score(X_test, y_test)))
plt.style.use('fivethirtyeight')
plt.scatter(reg.predict(X_train), reg.predict(X_train) - y_train,
color = "green", s = 10, label = 'Train data')
plt.scatter(reg.predict(X_test), reg.predict(X_test) - y_test,
color = "blue", s = 10, label = 'Test data')
plt.hlines(y = 0, xmin = 0, xmax = 50, linewidth = 2)
plt.legend(loc = 'upper right')
plt.title("Residual errors")
plt.show()Ausgabe
Coefficients:
[
-1.16358797e-01 6.44549228e-02 1.65416147e-01 1.45101654e+00
-1.77862563e+01 2.80392779e+00 4.61905315e-02 -1.13518865e+00
3.31725870e-01 -1.01196059e-02 -9.94812678e-01 9.18522056e-03
-7.92395217e-01
]
Variance score: 0.709454060230326
Annahmen
Im Folgenden sind einige Annahmen zum Datensatz aufgeführt, die vom linearen Regressionsmodell erstellt wurden:
Multi-collinearity- Das lineare Regressionsmodell geht davon aus, dass die Daten nur sehr wenig oder gar keine Multikollinearität aufweisen. Grundsätzlich tritt Multikollinearität auf, wenn die unabhängigen Variablen oder Merkmale von ihnen abhängig sind.
Auto-correlation- Eine andere Annahme Das lineare Regressionsmodell geht davon aus, dass die Daten nur sehr wenig oder gar nicht automatisch korrelieren. Grundsätzlich tritt eine Autokorrelation auf, wenn eine Abhängigkeit zwischen Restfehlern besteht.
Relationship between variables - Das lineare Regressionsmodell geht davon aus, dass die Beziehung zwischen Antwort- und Merkmalsvariablen linear sein muss.