Einfache Regression und multiple Regression

Einfache Regression: Eine Methode, die versucht, einen bestimmten Wert mithilfe einzelner Eingabedaten vorherzusagen.

Beispiel: Vorhersage des Gewichts anhand von Höhendaten. y=w₀+w₁X

--Multiple Regression: Eine Methode, die versucht, einen bestimmten Wert anhand von zwei oder mehr Eingabedaten vorherzusagen.

ex) Prognostizieren Sie das Gewicht anhand von Größe, Taille, Körperfett ... y=w₀+w₁x₁+w₂x₂+w₃x₃+…

Beispiel durch Polypoly-Regression

――Jetzt möchte ich die Daten wie in der folgenden Abbildung gezeigt zurückgeben. Es ist jedoch eindeutig eine Form, die nicht durch eine gerade Linie ausgedrückt werden kann.

Versucht eine Regression durch Polypoly-Regression.

--Multiple Regression ... Eine Art multiple Regressionsanalyse. Fügen Sie zusätzlich zu den Eingabedaten x x ^ 2, x ^ 3… als neue Eingabedaten hinzu.

Die Methode der kleinsten Quadrate ist nicht universell

Die Methode der kleinsten Quadrate ist ein Algorithmus, der das Modell kompliziert.

Probleme des mangelnden Lernens und Überlernens

Mangel an Lernen ... Situationen, in denen Trainingsdaten nicht vollständig ausgedrückt werden können. Die Verlustfunktion bleibt hoch.
Überlernen (Überanpassung): Eine Situation, in der die Trainingsdaten überangepasst sind. Die Generalisierungsleistung ist gering.

Die Technik der Regularisierung

--Regularisierung: Eine Methode zur Verhinderung von Überlernen durch Auswahl geeigneter Koeffizienten oder Reduzierung der Größe der Koeffizienten. Finden Sie einen wirklich wichtigen Koeffizienten.

--Variable Auswahl Allmähliche Auswahlmethode: Addieren oder reduzieren Sie die Koeffizienten nacheinander, um die Anpassungsgüte zu maximieren.

--Reduktionsschätzung (1) Ridge-Regression: Reduzieren Sie den absoluten Wert des Koeffizienten. (2) Lasso-Regression: Setzen Sie einige Koeffizienten vollständig auf 0.

Praxis (Polypoly-Regression)

import numpy as np
import matplotlib.pyplot as plt

data_size=20
#0~Bis zu 1 wird durch 20 Stück dargestellt.
X=np.linspace(0,1,data_size)

#Einheitliche Zufallszahl zwischen niedrig und hoch
noise=np.random.uniform(low=-1.0,high=1.0,size=data_size)*0.2

y=np.sin(2.0*np.pi*X)+noise

#0~Bis zu 1 wird durch 1000 Stück dargestellt.
X_line=np.linspace(0,1,1000)
sin_X=np.sin(2.0*np.pi*X_line)

def plot_sin():
    plt.scatter(X,y)
    plt.plot(X_line,sin_X,"red")
plot_sin()

from sklearn.linear_model import LinearRegression

#Generierung eines linearen Regressionsmodells
lin_reg_model=LinearRegression().fit(X.reshape(-1,1),y)

#Sektion,Neigung
lin_reg_model.intercept_,lin_reg_model.coef_

plt.plot(X_line,lin_reg_model.intercept_+lin_reg_model.coef_*X_line)
plot_sin()

from sklearn.preprocessing import PolynomialFeatures

#0. Potenz~Generieren Sie 4 Spalten bis zur 3. Potenz(20-mal-4-Datenrahmengenerierung)
poly = PolynomialFeatures(degree=3)
poly.fit(X.reshape(-1,1))
X_poly_3=poly.transform(X.reshape(-1,1))

lin_reg_3_model=LinearRegression().fit(X_poly_3,y)

X_line_poly_3=poly.fit_transform(X_line.reshape(-1,1))
plt.plot(X_line,lin_reg_3_model.predict(X_line_poly_3))
plot_sin()

fig,axes=plt.subplots(1,3,figsize=(16,4))

for degree,ax in zip([5,15,25],axes):
    poly=PolynomialFeatures(degree=degree)
    X_poly=poly.fit_transform(X.reshape(-1,1))
    lin_reg=LinearRegression().fit(X_poly,y)
    X_line_poly=poly.fit_transform(X_line.reshape(-1,1))
    ax.plot(X_line,lin_reg.predict(X_line_poly))
    ax.scatter(X,y)
    ax.plot(X_line,sin_X,"red")

Übung (Normalisierung)

import mglearn
import pandas as pd
from sklearn.model_selection import  train_test_split

X,y=mglearn.datasets.load_extended_boston()
df_X=pd.DataFrame(X)
dy_y=pd.DataFrame(y)

X_train,X_test,y_train,y_test=train_test_split(X,y,random_state=0)

lin_reg_model=LinearRegression().fit(X_train,y_train)

print(round(lin_reg_model.score(X_train,y_train),3))#Präzisionsrate der Trainingsdaten
print(round(lin_reg_model.score(X_test,y_test),3))#Testdatengenauigkeitsrate

Generierung eines Ridge-Regressionsmodells

from sklearn.linear_model import Ridge,Lasso

ridge_model=Ridge().fit(X_train,y_train)

def print_score(model):
    print(round(model.score(X_train,y_train),3))#Präzisionsrate der Trainingsdaten
    print(round(model.score(X_test,y_test),3))#Testdatengenauigkeitsrate

#Je größer das Alpha, desto kleiner der Absolutwert(default=1)
ridge_10_model=Ridge(alpha=10).fit(X_train,y_train)
print_score(ridge_10_model)


ridge_01_model=Ridge(alpha=0.1).fit(X_train,y_train)
print_score(ridge_01_model)

coefficients=pd.DataFrame({"lin_reg":lin_reg.coef_,"ridge_10_model":ridge_10_model.coef_,"ridge_01_model":ridge_01_model.coef_})
coefficients

Generierung von Lasso-Regressionsmodellen

lasso_001_model=Lasso(alpha=0.01,max_iter=10000).fit(X_train,y_train)
print_score(lasso_001_model)


coefficients_lasso=pd.DataFrame({"lin_reg":lin_reg.coef_,
                              
                                 "lasso_001_model":lasso_001_model.coef_})

[PYTHON] Ich habe eine multiple Regressionsanalyse mit Polypoly-Regression versucht