[PYTHON] J'ai essayé l'analyse de régression multiple avec régression polypoly
Régression simple et régression multiple
--Régression simple: méthode qui tente de prédire une certaine valeur à l'aide d'une seule donnée d'entrée.
ex) Prédire le poids en utilisant les données de taille. y=w₀+w₁X
--Régression multiple: méthode qui tente de prédire une certaine valeur à l'aide de deux ou plusieurs données d'entrée.
ex) Prédire le poids en utilisant la taille, la taille, la graisse corporelle ... y=w₀+w₁x₁+w₂x₂+w₃x₃+…
Exemple par régression polypoly
――Maintenant, je souhaite renvoyer les données comme indiqué dans la figure ci-dessous. Cependant, il s'agit clairement d'une forme qui ne peut pas être exprimée par une ligne droite.
- Tente de régression par régression polypoly.
--Régression multiple ... Un type d'analyse de régression multiple. En plus des données d'entrée x, ajoutez x ^ 2, x ^ 3… comme nouvelles données d'entrée.
La méthode des moindres carrés n'est pas universelle
- La méthode des moindres carrés est un algorithme qui tend à compliquer le modèle.
Problèmes de manque d'apprentissage et de surapprentissage
-
Manque d'apprentissage ... Situations où les données de formation ne peuvent pas être pleinement exprimées. La fonction de perte reste élevée.
-
Surapprentissage (suradaptation): situation dans laquelle les données d'entraînement sont suradaptées. Les performances de généralisation sont faibles.
La technique de régularisation
--Régularisation: une méthode pour éviter le surapprentissage en sélectionnant des coefficients appropriés ou en réduisant la taille des coefficients. Trouvez un coefficient vraiment important.
--Sélection variable Méthode de sélection graduelle: ajoutez ou réduisez les coefficients un par un pour maximiser la qualité de l'ajustement.
- Estimation de la réduction (1) Régression Ridge: Réduisez la valeur absolue du coefficient. (2) Régression par lasso: définissez complètement certains coefficients sur 0.
Pratique (régression polypoly)
import numpy as np
import matplotlib.pyplot as plt
data_size=20
#0~Jusqu'à 1 est représenté par 20 pièces.
X=np.linspace(0,1,data_size)
#Nombre aléatoire uniforme entre faible et élevé
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~Jusqu'à 1 est représenté par 1000 pièces.
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
#Génération de modèles de régression linéaire
lin_reg_model=LinearRegression().fit(X.reshape(-1,1),y)
#Section,Inclinaison
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
#0e puissance~Génère 4 colonnes jusqu'à la 3e puissance(Génération de trames de données 20 par 4)
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")
Pratique (normalisation)
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))#Taux de précision des données d'entraînement
print(round(lin_reg_model.score(X_test,y_test),3))#Taux de précision des données de test
Génération de modèles de régression Ridge
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))#Taux de précision des données d'entraînement
print(round(model.score(X_test,y_test),3))#Taux de précision des données de test
#Plus l'alpha est grand, plus la valeur absolue est petite(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
Génération de modèle de régression par lasso
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_})
Recommended Posts