Bases de l'apprentissage avec un enseignant Partie 1-Régression simple- (Remarque)

Revenir

Modèle de régression simple (linéaire)

Ce modèle génère un type de valeur prédite à partir d'un type de données. Lorsque les données d'entrée sont $ x = (x_1, x_2, \ cdots, x_n) $ et que les données de sortie sont $ y = (y_1, y_2, \ cdots, y_n) $, le modèle __ est le mieux représenté. Déterminez la pente $$ et la section $ b $ de la __ droite $ y = wx + b $. $ w $ s'appelle __weight __ et $ b $ s'appelle __bias __. Il y a une erreur entre les données réelles et le modèle ($ y = wx + b ). $ \ varepsilon = (\ varepsilon_1, \ varepsilon_2, \ cdots, \ varepsilon_n) $$. À ce stade, sur les données de chaque enseignant

y_i = wx_i+b+\varepsilon_i

Est établi. La meilleure représentation d'un modèle est lorsque vous avez déterminé la fonction __loss appropriée __ (par exemple, erreur de somme des carrés) et que le modèle (équation en ligne droite) la minimise. La fonction de perte $ L (w, b) $ est la somme des carrés d'erreur (également appelée somme résiduelle des carrés)

L(w, b):=\sum_{i=1}^n \{y_i-(wx_i+b)\}^2

Ensuite, vous pouvez voir que $ L (w, b) = \ sum_ {i = 1} ^ n \ varepsilon_i ^ 2 $, c'est-à-dire la somme des carrés des erreurs. Dans certains cas, multipliez par (1/2) (car la différenciation peut donner un coefficient de 1). Bien que les détails soient omis, $ w et b $ peuvent être obtenus en résolvant l'équation $ = 0 $, qui est une différenciation partielle de $ L (w, b) $ par $ w et b $, respectivement.

b = \bar{y}-w\bar{x}, \ w=\frac{Cov(x, y)}{Var(x)}=\frac{\sum_{i=1}^n(x_i-\bar{x})(y_i-\bar{y})}{\sum_{i=1}^n(x_i-\bar{x})}

Où $ \ bar {x} $ est la moyenne de $ x $, $ Var (x) $ est la variance de $ x $, et $ Cov (x, y) $ est la covariance de $ x $ et $ y $. Représente. Surtout sous ce $ (w, b) $

\begin{eqnarray}
&&y=wx+b=wx+(\bar{y}-w\bar{x})=\bar{y}+w(x-\bar{x})\\
&\Leftrightarrow& y-\bar{y}=w(x-\bar{x})
\end{eqnarray}

Par conséquent, la droite de régression passe par la moyenne de l'échantillon $ (\ bar {x}, \ bar {y}) $ des données observées.

la mise en oeuvre

Implémentez vous-même en Python et essayez de l'implémenter à l'aide du modèle linear_model LinearRegression de sklearn. Des graines aléatoires sont définies pour la reproductibilité. Tout d'abord, importez les bibliothèques requises.

import numpy as np
import matplotlib.pyplot as plt
from numpy.random  import randn

Ensuite, définissez la régression linéaire en tant que fonction.

def LinearRegression(x, y):
    n = len(x)
    temp_x = x.sum()/n
    temp_y = y.sum()/n
    w = ((x-temp_x)*(y-temp_y)).sum()/((x-temp_x)**2).sum()
    b = temp_y - w * temp_x
    return w, b

Et, comme données de l'enseignant, on suppose $ y = x + 1 + bruit $. $ noise $ est un nombre aléatoire qui suit une distribution normale standard multipliée par 0,1.

# initial value
# y=x+En supposant 1 plus de bruit
x = np.array([1,2,3,4,5])
np.random.seed(seed=0)
y = np.array([2,3,4,5,6])+np.random.randn(5)*0.1
print(y)
w, b = LinearRegression(x, y) 
print(w, b)

Si vous faites cela, vous obtiendrez environ $ w = 1,02, b = 1,08 $. Juste au cas où, visualisez-le avec un graphique.

plt.scatter(x, y, color="k")
xx = np.linspace(0, 5, 50)
yy = xx * w + b
plt.plot(xx, yy)
plt.show()

image.png

C'est un sentiment agréable!

Réécrivez le code pour le rendre plus facile à utiliser

Réécrivons le code en utilisant la classe. J'ai créé une classe appelée modèle, une méthode d'ajustement qui calcule les paramètres, une méthode de prédiction qui génère des prédictions et une méthode de score qui calcule les coefficients de décision. Plus le facteur de décision $ R ^ 2 $ est proche de 1, meilleure est la précision.

R^2:= 1-\frac{\sum_{i=1}^n (y_i-(wx_i+b))^2}{\sum_{i=1}^n (y_i-\bar{y})^2}

Est défini comme.

class model():
        
    def fit(self, X, y):
        n = len(X)
        temp_X = X.sum()/n
        temp_y = y.sum()/n
        self.w = ((X-temp_X)*(y-temp_y)).sum()/((X-temp_X)**2).sum()
        self.b = temp_y - self.w * temp_X
        
    def predict(self, X):
        return self.w*X +self.b
    
    def score(self, X, y):
        n = len(X)
        return  1 - ((y-(self.w*X+self.b))**2).sum() / ((y-y.sum()/n)**2).sum()

Saisissez les données de l'enseignant comme auparavant. De plus, laissez-moi le tester.

X = np.array([1,2,3,4,5])
np.random.seed(seed=0)
y = np.array([2,3,4,5,6])+np.random.randn(5)*0.1

lr = model()
lr.fit(X, y)
print("w, b={}, {}".format(w, b))

#données de test
test_X = np.array([6,7,8,9,10])
pre = lr.predict(test_X)
print(pre)

#Facteur de décision R^2
print(lr.score(X, y))

Faites un graphique.

#Afficher les résultats dans un graphique
plt.scatter(X, y, color="k")
plt.scatter(test_X, pre, color="r")
xx = np.linspace(0, 10, 50)
yy = xx * w + b
plt.plot(xx, yy)
plt.show()

image.png

Utiliser la bibliothèque de sklearn

Enfin, écrivons un code simple en utilisant LinearRegression () de linear_model.

from sklearn import linear_model

X = np.array([1,2,3,4,5])
np.random.seed(seed=0)
y = np.array([2,3,4,5,6])+np.random.randn(5)*0.1

X = X.reshape(-1,1)
model = linear_model.LinearRegression()
model.fit(X, y)
print(model.coef_[0])
print(model.intercept_)
#Facteur de décision R^2
print(model.score(X, y))

$ w $ correspond à coef_ [0] et $ b $ correspond à intercept_. Vous pouvez voir que les valeurs correspondent. Le point à noter ici est que dans le cas de données d'entrée unidimensionnelles, entrez comme $ X = np.array ([[1], [2], [3], [4], [5]]) $. est nécessaire. Si $ X = np.array ([1,2,3,4,5]) $, une erreur sera renvoyée. Ensuite, faisons une prédiction en utilisant les données de test.

test_X = test_X.reshape(-1,1)
pre = model.predict(test_X)

Faites un graphique.

plt.scatter(X, y)
plt.scatter(test_X, pre)
plt.plot(xx, model.coef_[0]*xx+model.intercept_)
plt.show()

image.png

Résumé

Si vous écrivez du code en utilisant sklearn, vous pouvez facilement l'appeler comme suit. Cela peut être appliqué à peu près de la même manière avec d'autres méthodes. Il ne reste que des éléments optionnels tels que les paramètres et la division des données des enseignants en données de formation et données de test.

#Définir le modèle
model = linear_model.LinearRegression()
#Apprentissage(X:Données d'entrée, y:Étiquette de réponse correcte)
model.fit(X, y)
#Prévoir(XX:Données inconnues)
model.predict(XX)

C'est tout pour la régression simple (méthode du carré minimum). Continuez à la prochaine fois. .. ..

Postscript

Si vous y réfléchissez, cela aurait dû être $ b = (b, b, \ cdots, b) \ in \ mathbf {\ mathrm {R}} ^ n $. En code Python, grâce à la diffusion, la somme avec les vecteurs et les matrices peut être calculée automatiquement même en scalaire $ b $.

Addendum 2

from sklearn import linear_model

Mais

from sklearn.linear_model import LinearRegression

Est plus facile. Je me demande si cela est également courant dans d'autres livres.

Les références

Recommended Posts

Bases de l'apprentissage avec un enseignant Partie 1-Régression simple- (Remarque)
Bases de l'apprentissage avec un enseignant Partie 3-Régression multiple (mise en œuvre) - (Notes) -
Apprendre avec un enseignant (retour) 1 Bases
Apprendre avec l'enseignant 1 Principes de base de l'apprentissage avec l'enseignant (classification)
Python: Application de l'apprentissage supervisé (retour)
Bases de l'analyse de régression
Python: apprentissage supervisé (retour)
Machine Learning: Supervision - Régression linéaire
Bases de l'apprentissage automatique (mémoire)
Python: Apprentissage supervisé: Hyper Paramètres Partie 1
Python: apprentissage supervisé: Hyper Paramètre partie 2
Apprendre avec l'enseignant (retour) 2 édition avancée
Machine learning supervisé (classification / régression)
Principes de base de Python x SIG (1)
Principes de base de Python x SIG (3)
Algorithme d'apprentissage automatique (analyse de régression unique)
Principes de base de Python x SIG (partie 2)
Algorithme d'apprentissage automatique (généralisation de la régression linéaire)
[Lecture de l'article] Apprentissage auto-supervisé Commentaire de l'article part1 ~ suivi dense Histoire du développement ~
Apprentissage automatique avec python (2) Analyse de régression simple
Apprentissage supervisé (classification)
Python: apprentissage supervisé (classification)
Algorithme de recherche utilisant word2vec [python]
Apprendre avec l'enseignant 1 Principes de base de l'apprentissage avec l'enseignant (classification)
Machine learning supervisé (classification / régression)
Mémo d'apprentissage automatique d'un ingénieur débutant Partie 1
Classification des images de guitare par apprentissage automatique Partie 1
[Cx_Oracle Primer] (Partie 3) Bases de la navigation dans les tableaux
Apprentissage de la reconnaissance de formes en vidéo Partie 1 Champ de reconnaissance de formes
[Apprentissage automatique] Apprentissage supervisé utilisant l'estimation de la densité du noyau Partie 2
EV3 x Python Machine Learning Partie 2 Régression linéaire
[Apprentissage automatique] Apprentissage supervisé utilisant l'estimation de la densité du noyau Partie 3
Mémo d'apprentissage automatique d'un ingénieur débutant Partie 2
Classification des images de guitare par apprentissage automatique, partie 2
[Python] Note d'apprentissage 1
Report_Apprentissage approfondi (partie 2)
Report_Apprentissage approfondi (partie 1)
Report_Apprentissage approfondi (partie 2)
Les bases de Python ①
Bases de python ①
Apprendre sans enseignant 1 Principes de base
Apprentissage supervisé (classification)
Note d'apprentissage Python de Mayungo: liste d'histoires et de liens
Explication du concept d'analyse de régression à l'aide de python Partie 2
Python Scikit-learn Analyse de régression linéaire Analyse de régression simple non linéaire Apprentissage automatique
Calculer le coefficient de régression d'une analyse de régression simple avec python
Explication du concept d'analyse de régression à l'aide de Python Partie 1
Apprendre en profondeur à partir des bases mathématiques Partie 2 (pendant la fréquentation)
[Introduction à cx_Oracle] (Partie 11) Bases de l'exécution PL / SQL
Une note d'essayer un simple tutoriel MCMC sur PyMC3
J'ai appris les bases de l'apprentissage intensif et joué avec Cart Pole (implémentation simple de Q Learning)