[PYTHON] Lineare Regression

Was ist lineare Regression?

Eine Methode zum Erstellen einer linearen Funktion (Vorhersagemodell), die die Zielvariable (vorhergesagte Daten) unter Verwendung erklärender Variablen (zur Vorhersage verwendete Daten) vorhersagt. Das Lernen, ein Vorhersagemodell zu erstellen, ist erforderlich, um Vorhersagen zu treffen. = Betreutes Lernen

Unter der Annahme, dass die horizontale Achse der folgenden Abbildung die erklärende Variable ist, die vertikale Achse die Zielvariable ist und der rote Punkt erhalten wird, ist die blaue Linie die Regressionsgleichung (Vorhersagemodell aus dem Lernen). Sobald diese Regressionsgleichung erstellt ist und eine unbekannte erklärende Variable eingeht, kann ich vorhersagen, wie die Zielvariable zu diesem Zeitpunkt aussehen wird.

Die Methode zum Erstellen der Regressionsgleichung verwendet die Methode des minimalen Quadrats (eine Methode zum Minimieren des Quadrats (quadratischer Fehler) der Differenz zwischen dem Wert der tatsächlichen Zielvariablen und dem vorhergesagten Wert).

Wenn in der obigen Abbildung eine vertikale Linie der x-Achse vom roten Punkt zur blauen Linie gezogen wird, wird die Länge zu einem Fehler. Ein Bild, das dies unter Berücksichtigung der Auswirkungen von Plus und Minus quadriert und den Gesamtwert minimiert.

Vorbereitung der Nutzungsdaten

Verwenden Sie Boston Home Preisdaten.

{get_boston_house_price_dataset.py}

import numpy as np
import pandas as pd
from pandas import Series, DataFrame

import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style('whitegrid')
%matplotlib inline

from sklearn.datasets import load_boston
boston = load_boston() #Holen Sie sich Boston Home Preisdaten

#In Datenrahmen konvertieren
boston_df = DataFrame(boston.data)
boston_df.columns = boston.feature_names
boston_df['Price'] = boston.target

Datenübersicht

{describe_boston_house_price_dataset.py}

boston_df[['RM', 'Price']].describe()

RM ist die Anzahl der Zimmer. Preis ist der Preis. Um den Preis (Zielvariable) vorherzusagen, verwenden wir die Anzahl der Zimmer als erklärende Variable.

Lassen Sie uns einen kurzen Blick auf die Beziehung zwischen der Anzahl der Zimmer und dem Preis werfen.

{scatter_plot_boston_house_price_dataset.py}

#RM: Anzahl der Räume auf der horizontalen Achse, Preis:Versuchen Sie, ein Streudiagramm mit dem Preis auf der vertikalen Achse zu zeichnen
plt.scatter(boston_df['RM'], boston_df['Price'])
plt.xlabel('Number of rooms')
plt.ylabel('Price($1,000)')
plt.title('Scatter Plot')

Das Streudiagramm ist wie oben. Es scheint eine positive Korrelation zu bestehen (der Preis steigt mit zunehmender Anzahl der Zimmer).

Berechnen wir daher den Korrelationskoeffizienten.

{calculate_correration.py}

np.corrcoef (boston_df['RM'], boston_df['Price'])[0,1]
> 0.69535994707153925

Korrelationskoeffizient 0,695 stärker. Die Verwendung von RM als erklärende Variable scheint also keine schlechte Idee zu sein.

Probieren Sie es aus (einzelne Regression)

1. 1. Schauen wir uns die Regressionsgleichung gleichzeitig mit dem Streudiagramm mit dem lmplot von seaborn an

{make_lmplot.py}

sns.lmplot('RM', 'Price', data = boston_df) 

Sehr leicht. lmplot-Option von seaborn: Übergeben Sie einfach einen DataFrame an data und geben Sie die DataFrame-Spaltennamen für die X- und Y-Achse an, um eine Linie zu erstellen.

2. Versuchen Sie es mit Numpy

{calcurate_single_regression.py}

#Daten in Feed-Nummer umwandeln [* 1]
X = np.vstack(boston_df.RM) 
X = np.array([[value, 1] for value in X])
#Bereiten Sie die Zielvariable vor
Y = boston_df.Price

#Lineare Regression(np.linalg.lstsq)Um a:Tilt, b:Holen Sie sich einen Abschnitt. [* 2]
a, b = np.linalg.lstsq(X, Y)[0] 

#Zeichnen Sie ein Streudiagramm und fügen Sie die Regressionsgleichung aus den erhaltenen Ergebnissen hinzu.
plt.plot(boston_df.RM, boston_df.Price, 'o')
x = boston_df.RM
#Die Regressionsgleichung lautet y= a * x +Da es durch b ausgedrückt werden kann, liegt x auf der x-Achse und a auf der y-Achse.* x +Geben Sie b an.
plt.plot(x, a * x + b, 'r')
#Beschriftung der x- und y-Achse
plt.xlabel('Number of Room')
plt.ylabel('Price($1,000)')

Diagramm des Ergebnisses der linearen Regression mit Numpy. Die Regressionsgleichung, aus der die rote Linie erhalten wurde.

Probieren Sie es aus (multiple Regression)

Verwenden Sie Scikit-Learn

Bei der einfachen Regression wird eine erklärende Variable verwendet, während bei der multiplen Regression mehrere erklärende Variablen verwendet werden. In boston_df gibt es 13 Variablen, einschließlich RM: Anzahl der Räume. Erstellen wir also ein Modell, das den Preis anhand dieser vorhersagt.

Bei der Erstellung eines Vorhersagemodells verwenden wir eine Methode, um es für Training und Test zu trennen. Der Grund für die Aufteilung ist, dass "wenn Sie nur die Genauigkeit der Trainingsdaten betrachten, Sie nicht beurteilen können, ob sie zur Vorhersage unbekannter Daten verwendet werden können".

{do_multiple_regression.py}

import sklearn
from sklearn.linear_model import LinearRegression #Für die lineare Regression

#Bestätigung der Nutzungsdaten(Es gibt 14 Daten von CRIM zu Price. Der Preis ist die Zielvariable. Versuchen Sie also, die anderen 13 als erklärende Variablen zu verwenden.)
boston_df.info()
> <class 'pandas.core.frame.DataFrame'>
> Int64Index: 506 entries, 0 to 505
> Data columns (total 14 columns):
> CRIM       506 non-null float64
> ZN         506 non-null float64
> INDUS      506 non-null float64
> CHAS       506 non-null float64
> NOX        506 non-null float64
> RM         506 non-null float64
> AGE        506 non-null float64
> DIS        506 non-null float64
> RAD        506 non-null float64
> TAX        506 non-null float64
> PTRATIO    506 non-null float64
> B          506 non-null float64
> LSTAT      506 non-null float64
> Price      506 non-null float64
> dtypes: float64(14)

#Erstellen Sie einen DataFrame für andere erklärende Variablen als Price
X_multi = boston_df.drop('Price', 1) 
X_multi.shape
> (506, 13)

#Trennen Sie die Daten für Zug und Test.
# sklearn.cross_validation.train_test_split(X, Y)Wenn Sie X als erklärende Variable und Y als Zielvariable angeben, wird es schnell getrennt.
X_train, X_test, Y_train, Y_test = sklearn.cross_validation.train_test_split(X_multi, boston_df.Price) 

#Überprüfen Sie die Anzahl der geteilten Daten
print(X_train.shape, X_test.shape, Y_train.shape, Y_test.shape)
> (379, 13) (127, 13) (379,) (127,)
#Sie können sehen, dass es in 379 für Zug und 127 für Test unterteilt wurde.

#Instanzgenerierung
lreg = LinearRegression()
#Implementierung der Erstellung mehrerer Regressionsmodelle
lreg.fit(X_train, Y_train)
#Vorhersageimplementierung für Trainingsdaten und Testdaten
pred_train = lreg.predict(X_train)
pred_test = lreg.predict(X_test) 

#Überprüfen Sie den durchschnittlichen quadratischen Fehler zwischen den Trainingsdaten und den Testdaten[average(Aktueller Preis-Voraussichtlicher Wert]^2)]
np.mean((Y_train - pred_train) ** 2)
> 20.5592370941859
np.mean((Y_test - pred_test) ** 2) 
> 28.169312238554202

#Überprüfen Sie den Rest der tatsächlich richtigen Antwort und die Vorhersage in der Grafik.
#Die horizontale Achse zeigt das Ergebnis des Zuges und die vertikale Achse zeigt den Fehler.
train = plt.scatter(pred_train, (pred_train - Y_train), c= 'b', alpha=0.5)  
#Die horizontale Achse zeigt das Testergebnis und die vertikale Achse zeigt den Fehler.
test = plt.scatter(pred_test, (pred_test - Y_test), c ='r', alpha=0.5)

#Anordnung des Graphen
#Zeichnen Sie eine Linie mit dem Fehler Null.
plt.hlines(y = 0, xmin = -1.0, xmax = 50)
#Gebrauchsanweisung
plt.legend((train, test), ('Training', 'Test'), loc = 'lower left') #Gebrauchsanweisung
#Titel
plt.title('Residual Plots')

Ergebnis des Fehlerplots

Die schwarze horizontale Linie stellt Fehler = 0 dar. Wenn sich ein Punkt darüber befindet, ist der Fehler positiv, und wenn er darunter liegt, ist der Fehler negativ. Wenn dieser Fehler gleichmäßig auf und ab verteilt ist, kann gesagt werden, dass er zur Lösung dieser Vorhersage durch lineare Regression geeignet ist. Wenn dieser Fehler jedoch ein verzerrtes Ergebnis ist, ist es besser, die Anwendung der linearen Regression selbst zu überprüfen.

Ergänzung

[* 1] Informationen zur Datenformatierung zur Verwendung mit npmpy

Die Geradengleichung der einfachen Regression kann ausgedrückt werden als y = ax + b, dies kann jedoch in die Vektornotation umgewandelt werden. Es kann umgeschrieben werden als y = Ap.

A und p sind jeweils wie folgt und dieses innere Produkt ist y. (y = a * x + b * 1)

Es ist in diese Form geformt.

{.py}

# boston_df.Mit RM ist es ein eindimensionales Array.
X = boston_df.RM
#Überprüfen Sie die Form der X-Matrix(Eindimensionales Array mit nur 506 Zeilen)
X.shape
> (506,)
X
>0     6.575
>1     6.421
>2     7.185
>...
>504    6.794
>505    6.030
>Name: RM, Length: 506, dtype: float64

Um dies mit numpy zu verwenden, müssen Sie es in ein zweidimensionales Array ändern.

{.py}

#Also np in ein zweidimensionales Array konvertieren.Verwenden Sie vstack.
X = np.vstack(boston_df.RM)
#Überprüfen Sie die Form der X-Matrix(Zeile 506,1 Spalte 2D-Array)
X.shape
>(506, 1)
X
>array([[ 6.575],
>       [ 6.421],
>       [ 7.185],
>・ ・ ・
>       [ 6.794],
>       [ 6.03 ]])

{.py}

#Weiter diese A.= [x, 1]Umstellung auf. Stellen Sie den Wert von X auf die 1. Dimension und 1 auf die 2. Dimension als festen Wert ein
X = np.array([[value, 1] for value in X])
#Überprüfen Sie die Form der X-Matrix(Zeile 506,Zweispaltiges zweidimensionales Array)
X.shape
> (506, 2)
X
>array([[array([ 6.575]), 1],
>       [array([ 6.421]), 1],
>       [array([ 7.185]), 1],
>       ..., 
>       [array([ 6.976]), 1],
>       [array([ 6.794]), 1],
>       [array([ 6.03]), 1]], dtype=object)

Nun hat die erklärende Variable X die Form von [x 1], die von numpy behandelt werden kann.

[* 2] Über np.linalg.lstsq

linalg ist eine Abkürzung für lineare Algebra und lstsq ist eine Abkürzung für Least Square (Minimum Square-Methode).

Der Rückgabewert ist 0. Zeile: Steigung und Abschnitt, 1. Zeile: Residuum, 2. Zeile: Rang der erklärenden Variablen, 3. Zeile: Singularwert der erklärenden Variablen (Singlar-Wert). Da wir diesmal die Steigung und den Abschnitt ermitteln möchten, geben Sie [0] an.