[PYTHON] 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
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
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()
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()
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()
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
- Koichi Kato "Essence of Machine Learning" SB Creative, 2019