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à.

スクリーンショット 2016-05-03 11.42.20.png

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()
スクリーンショット 2016-05-03 12.07.01.png

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')
スクリーンショット 2016-05-03 12.10.07.png

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) 
スクリーンショット 2016-05-03 12.22.38.png

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.

スクリーンショット 2016-05-03 12.54.10.png

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

スクリーンショット 2016-05-03 14.41.15.png

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) スクリーンショット 2016-05-03 13.54.20.png

スクリーンショット 2016-05-03 13.54.28.png

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

Régression linéaire
Régression linéaire avec statsmodels
Régression linéaire d'apprentissage automatique
Régression avec un modèle linéaire
Machine Learning: Supervision - Régression linéaire
Méthode de régression linéaire utilisant Numpy
[Python] Régression linéaire avec scicit-learn
Régression linéaire en ligne en Python
Régression linéaire robuste avec scikit-learn
Retour logistique
Les débutants en apprentissage automatique essaient la régression linéaire
Retour logistique
Régression linéaire avec distribution t de Student
Régression linéaire (pour les débutants) -Édition de code-
Premier TensorFlow (édition révisée) - Régression linéaire et logistique
Algorithme d'apprentissage automatique (généralisation de la régression linéaire)
Régression linéaire en Python (statmodels, scikit-learn, PyMC3)
Différence entre la régression linéaire, la régression Ridge et la régression Lasso
Reproduction sur plaque de régression linéaire bayésienne (PRML §3.3)
À propos de l'équation normale de la régression linéaire
Comprendre les types de données et le début de la régression linéaire
Algorithme d'apprentissage automatique (résumé de régression linéaire et régularisation)
Implémenté en Python PRML Chapitre 3 Régression linéaire bayésienne
Introduction à OPTIMIZER ~ De la régression linéaire à Adam à Eve
A propos des modèles linéaires
Prédire l'été chaud avec un modèle de régression linéaire
EV3 x Python Machine Learning Partie 2 Régression linéaire
Analyse de régression de Poisson
Prédiction des prix des logements (retour par régression linéaire (kaggle)) ver1.0
Méthode d'analyse de régression
"Régression linéaire" et "Version probabiliste de la régression linéaire" en Python "Régression linéaire de Bayes"
Implémentation python de la classe de régression linéaire bayésienne
Python Scikit-learn Analyse de régression linéaire Analyse de régression simple non linéaire Apprentissage automatique
Régression linéaire multiple, régression logistique, perceptron multicouche, encodeur automatique, Chainer Yo!
Introduction à l'hypothèse Tensorflow-About et au coût de la régression linéaire
[TensorFlow] Régression linéaire carrée minimale par méthode de descente de gradient (méthode de descente la plus raide)
Coursera Machine Learning Challenge en Python: ex1 (régression linéaire)