Régression linéaire
Qu'est-ce que la régression linéaire?
Méthode de création d'une fonction linéaire (modèle de prédiction) qui prédit la variable objective (données prédites) à l'aide de variables explicatives (données utilisées pour la prédiction). Apprendre à créer un modèle de prédiction est nécessaire pour faire des prédictions. = Apprentissage supervisé
En supposant que l'axe horizontal de la figure ci-dessous est la variable explicative, l'axe vertical est la variable objective et le point rouge correspond aux données obtenues, la ligne bleue est l'équation de régression (modèle de prédiction obtenu à partir de l'apprentissage). Une fois cette équation de régression créée, si une variable explicative inconnue entre en jeu, je sens que je peux prédire quelle sera la variable objective à ce moment-là.
La méthode de création de l'équation de régression utilise la méthode du carré minimum (une méthode de minimisation du carré (erreur carrée) de la différence entre la valeur de la variable objective réelle et la valeur prédite).
Dans la figure ci-dessus, si une ligne verticale de l'axe des x est tracée du point rouge à la ligne bleue, la longueur devient une erreur. Une image qui met cela au carré en tenant compte des effets du plus et du moins et minimise la valeur totale.
Préparation des données d'utilisation
Utilisez les données de prix des maisons de Boston.
{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() #Obtenez des données sur les prix des maisons de Boston
#Convertir en bloc de données
boston_df = DataFrame(boston.data)
boston_df.columns = boston.feature_names
boston_df['Price'] = boston.target
Aperçu des données
{describe_boston_house_price_dataset.py}
boston_df[['RM', 'Price']].describe()
RM est le nombre de pièces. Le prix est le prix. Afin de prédire le prix (variable objective), utilisons le nombre de chambres comme variable explicative.
Jetons un coup d'œil sur la relation entre le nombre de chambres et le prix.
{scatter_plot_boston_house_price_dataset.py}
#RM: Nombre de chambres sur l'axe horizontal, Prix:Essayez de dessiner un nuage de points avec le prix sur l'axe vertical
plt.scatter(boston_df['RM'], boston_df['Price'])
plt.xlabel('Number of rooms')
plt.ylabel('Price($1,000)')
plt.title('Scatter Plot')
Le diagramme de dispersion est comme ci-dessus. Il semble y avoir une corrélation positive (le prix augmente à mesure que le nombre de chambres augmente).
Par conséquent, calculons le coefficient de corrélation.
{calculate_correration.py}
np.corrcoef (boston_df['RM'], boston_df['Price'])[0,1]
> 0.69535994707153925
Coefficient de corrélation 0,695 plus fort. Donc, utiliser RM comme variable explicative ne semble pas être une mauvaise idée.
Essayez-le (régression simple)
1. 1. Regardons l'équation de régression en même temps que le diagramme de dispersion avec le lmplot de Seaborn
{make_lmplot.py}
sns.lmplot('RM', 'Price', data = boston_df)
Très facile. Option seaborn lmplot: transmettez un DataFrame aux données et spécifiez le nom de colonne du DataFrame pour les axes X et Y afin de créer une ligne.
2. Essayez avec numpy
{calcurate_single_regression.py}
#Transformez les données en flux numpy [* 1]
X = np.vstack(boston_df.RM)
X = np.array([[value, 1] for value in X])
#Préparez la variable objectif
Y = boston_df.Price
#Régression linéaire(np.linalg.lstsq)Pour exécuter un:Inclinaison, b:Obtenez une section. [* 2]
a, b = np.linalg.lstsq(X, Y)[0]
#Dessinez un diagramme de dispersion et ajoutez l'équation de régression à partir des résultats obtenus.
plt.plot(boston_df.RM, boston_df.Price, 'o')
x = boston_df.RM
#L'équation de régression est y= a * x +Puisqu'il peut être exprimé par b, x est sur l'axe des x et a est sur l'axe des y.* x +Précisez b.
plt.plot(x, a * x + b, 'r')
#Étiquetage des axes x et y
plt.xlabel('Number of Room')
plt.ylabel('Price($1,000)')
Diagramme du résultat de la régression linéaire avec numpy. L'équation de régression à partir de laquelle la ligne rouge a été obtenue.
Essayez-le (régression multiple)
Utilisez scikit-learn
La régression simple utilise une variable explicative, tandis que la régression multiple utilise plusieurs variables explicatives. Il y a 13 variables dans boston_df, y compris RM: nombre de chambres, alors créons un modèle qui prédit le prix en les utilisant.
Lors de la création d'un modèle prédictif, nous utilisons une méthode pour le séparer pour l'entraînement et le test. La raison de la division est que "si vous regardez uniquement l'exactitude des données d'entraînement, vous ne pouvez pas juger si elles peuvent être utilisées pour prédire des données inconnues."
{do_multiple_regression.py}
import sklearn
from sklearn.linear_model import LinearRegression #Pour la régression linéaire
#Confirmation des données d'utilisation(Il y a 14 données de CRIM à Price. Le prix est la variable objective, alors essayez d'utiliser les 13 autres comme variables explicatives.)
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)
#Créer DataFrame pour les variables explicatives autres que Price
X_multi = boston_df.drop('Price', 1)
X_multi.shape
> (506, 13)
#Séparez les données pour le train et le test.
# sklearn.cross_validation.train_test_split(X, Y)Si vous spécifiez X comme variable explicative et Y comme variable objectif, elle sera rapidement séparée.
X_train, X_test, Y_train, Y_test = sklearn.cross_validation.train_test_split(X_multi, boston_df.Price)
#Vérifiez le nombre de données divisées
print(X_train.shape, X_test.shape, Y_train.shape, Y_test.shape)
> (379, 13) (127, 13) (379,) (127,)
#Vous pouvez voir qu'il a été divisé en 379 pour le train et 127 pour le test.
#Génération d'instance
lreg = LinearRegression()
#Implémentation de la création de modèles de régression multiple
lreg.fit(X_train, Y_train)
#Implémentation de prédiction pour les données d'entraînement et les données de test
pred_train = lreg.predict(X_train)
pred_test = lreg.predict(X_test)
#Vérifiez l'erreur quadratique moyenne entre les données d'entraînement et les données de test[average(Prix actuel-Valeur prédite]^2)]
np.mean((Y_train - pred_train) ** 2)
> 20.5592370941859
np.mean((Y_test - pred_test) ** 2)
> 28.169312238554202
#Vérifiez le résidu de la bonne réponse réelle et la prédiction sur le graphique.
#L'axe horizontal montre le résultat du train et l'axe vertical montre l'erreur.
train = plt.scatter(pred_train, (pred_train - Y_train), c= 'b', alpha=0.5)
#L'axe horizontal montre le résultat du test et l'axe vertical montre l'erreur.
test = plt.scatter(pred_test, (pred_test - Y_test), c ='r', alpha=0.5)
#Disposition du graphique
#Tracez une ligne sans erreur.
plt.hlines(y = 0, xmin = -1.0, xmax = 50)
#Guide d'utilisation
plt.legend((train, test), ('Training', 'Test'), loc = 'lower left') #Guide d'utilisation
#Titre
plt.title('Residual Plots')
Résultat du tracé d'erreur
La ligne horizontale noire représente l'erreur = 0, et s'il y a un point au-dessus, l'erreur est positive, et si elle est en dessous, l'erreur est négative. Si cette erreur est uniformément répartie de haut en bas, on peut dire qu'elle convient pour résoudre cette prédiction par régression linéaire. Cependant, si cette erreur est un résultat biaisé, il est préférable de revoir l'application de la régression linéaire elle-même.
Supplément
[* 1] À propos du formatage des données à utiliser avec npmpy
L'équation en ligne droite de la régression simple peut être exprimée comme y = ax + b, mais cela peut être converti en notation vectorielle. Il peut être réécrit comme y = Ap.
A et p sont chacun comme suit, et ce produit interne est y. (y = a * x + b * 1)
Il a cette forme.
{.py}
# boston_df.Avec RM, c'est un tableau unidimensionnel.
X = boston_df.RM
#Vérifiez la forme de la matrice X(Tableau unidimensionnel avec seulement 506 lignes)
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
Pour l'utiliser avec numpy, vous devez le changer en un tableau à deux dimensions.
{.py}
#Donc np pour convertir en un tableau à deux dimensions.Utilisez vstack.
X = np.vstack(boston_df.RM)
#Vérifiez la forme de la matrice X(Ligne 506,Tableau 2D 1 colonne)
X.shape
>(506, 1)
X
>array([[ 6.575],
> [ 6.421],
> [ 7.185],
>・ ・ ・
> [ 6.794],
> [ 6.03 ]])
{.py}
#Plus loin ce A= [x, 1]Conversion en. Définissez la valeur de X sur la 1ère dimension et de 1 sur la 2ème dimension comme valeur fixe
X = np.array([[value, 1] for value in X])
#Vérifiez la forme de la matrice X(Ligne 506,Tableau bidimensionnel à deux colonnes)
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)
Maintenant, la variable explicative X se présente sous la forme de [x 1], qui peut être gérée par numpy.
[* 2] À propos de np.linalg.lstsq
linalg est une abréviation pour Algèbre linéaire et lstsq est une abréviation pour Moindres carrés (méthode du carré minimum).
La valeur de retour est 0ème ligne: pente et section, 1ère ligne: résiduel, 2ème ligne: rang de la variable explicative, 3ème ligne: valeur singulière de la variable explicative (valeur singulière). Puisque nous voulons trouver la pente et la section cette fois, spécifiez [0].
Recommended Posts