[PYTHON] Grundlagen des Lernens mit einem Lehrer Teil 1 - Einfache Regression - (Hinweis)
Rückkehr
(Lineares) einfaches Regressionsmodell
Dieses Modell gibt einen vorhergesagten Werttyp aus einem Datentyp aus.
Wenn die Eingabedaten
y_i = wx_i+b+\varepsilon_i
Ist festgelegt. Die beste Darstellung eines Modells ist, wenn Sie die entsprechende __verlust-Funktion __ (z. B. Summe der Fehlerquadrate) ermittelt haben und das Modell (Geradengleichung) diese minimiert. Die Verlustfunktion $ L (w, b) $ ist der Fehler der Quadratsumme (auch Restquadratsumme genannt).
L(w, b):=\sum_{i=1}^n \{y_i-(wx_i+b)\}^2
Dann können Sie sehen, dass
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})}
Wobei $ \ bar {x} $ der Durchschnitt von $ x $ ist, $ Var (x) $ die Varianz von $ x $ ist und $ Cov (x, y) $ die Kovarianz von $ x $ und $ y $ ist. Repräsentiert. Besonders unter diesem $ (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}
Daher verläuft die Regressionslinie durch den Stichprobenmittelwert $ (\ bar {x}, \ bar {y}) $ der beobachteten Daten.
Implementierung
Implementieren Sie selbst in Python und versuchen Sie, mithilfe des linear_model LinearRegression-Modells von sklearn zu implementieren. Zufällige Samen werden zur Reproduzierbarkeit eingestellt. Importieren Sie zunächst die erforderlichen Bibliotheken.
import numpy as np
import matplotlib.pyplot as plt
from numpy.random import randn
Definieren Sie als Nächstes die lineare Regression als Funktion.
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
Und als Lehrerdaten wird $ y = x + 1 + Rauschen $ angenommen. $ Noise $ ist eine Zufallszahl, die einer Standardnormalverteilung multipliziert mit 0,1 folgt.
# initial value
# y=x+Angenommen, 1 plus Rauschen
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)
Wenn Sie dies tun, erhalten Sie ungefähr $ w = 1,02, b = 1,08 $. Visualisieren Sie es für alle Fälle mit einem Diagramm.
plt.scatter(x, y, color="k")
xx = np.linspace(0, 5, 50)
yy = xx * w + b
plt.plot(xx, yy)
plt.show()
Es ist ein gutes Gefühl!
Schreiben Sie den Code neu, um die Verwendung zu vereinfachen
Schreiben wir den Code mithilfe der Klasse neu. Ich habe eine Klasse namens model erstellt, eine Anpassungsmethode, die Parameter berechnet, eine Vorhersagemethode, die Vorhersagen ausgibt, und eine Bewertungsmethode, die Entscheidungskoeffizienten berechnet. Je näher der Entscheidungsfaktor $ R ^ 2 $ an 1 liegt, desto besser ist die Genauigkeit.
R^2:= 1-\frac{\sum_{i=1}^n (y_i-(wx_i+b))^2}{\sum_{i=1}^n (y_i-\bar{y})^2}
Ist definiert als.
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()
Geben Sie die Lehrerdaten wie zuvor ein. Lassen Sie es mich außerdem testen.
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))
#Testdaten
test_X = np.array([6,7,8,9,10])
pre = lr.predict(test_X)
print(pre)
#Entscheidungsfaktor R.^2
print(lr.score(X, y))
Machen Sie ein Diagramm.
#Ergebnisse in einem Diagramm anzeigen
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()
Verwenden Sie die Bibliothek von sklearn
Zum Schluss schreiben wir einen einfachen Code mit LinearRegression () von 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_)
#Entscheidungsfaktor R.^2
print(model.score(X, y))
$ w $ entspricht coef_ [0] und $ b $ entspricht intercept_. Sie können sehen, dass die Werte übereinstimmen. Hierbei ist zu beachten, dass bei eindimensionalen Eingabedaten $ X = np.array ([[1], [2], [3], [4], [5]]) $ eingegeben wird. wird gebraucht. Wenn $ X = np.array ([1,2,3,4,5]) $ ist, wird ein Fehler ausgegeben. Als nächstes machen wir eine Vorhersage unter Verwendung der Testdaten.
test_X = test_X.reshape(-1,1)
pre = model.predict(test_X)
Machen Sie ein Diagramm.
plt.scatter(X, y)
plt.scatter(test_X, pre)
plt.plot(xx, model.coef_[0]*xx+model.intercept_)
plt.show()
Zusammenfassung
Wenn Sie Code mit sklearn schreiben, können Sie ihn einfach wie folgt aufrufen. Dies kann auf die gleiche Weise wie bei anderen Methoden angewendet werden. Alles, was übrig bleibt, sind optionale Elemente wie Parameter und die Aufteilung der Lehrerdaten in Trainingsdaten und Testdaten.
#Modell definieren
model = linear_model.LinearRegression()
#Lernen(X:Eingabedaten, y:Richtiges Antwortetikett)
model.fit(X, y)
#Prognose(XX:Unbekannte Daten)
model.predict(XX)
Das ist alles für eine einfache Regression (Minimum-Square-Methode). Fahren Sie mit dem nächsten Mal fort. .. ..
Nachtrag
Wenn Sie darüber nachdenken, sollte es $ b = (b, b, \ cdots, b) \ in \ mathbf {\ mathrm {R}} ^ n $ gewesen sein. Im Python-Code kann dank Broadcast die Summe mit Vektoren und Matrizen automatisch berechnet werden, selbst als Skalar $ b $.
Nachtrag 2
from sklearn import linear_model
Aber
from sklearn.linear_model import LinearRegression
Ist einfacher. Ich frage mich, ob dies auch in anderen Büchern üblich ist.
Verweise
- Koichi Kato "Essenz des maschinellen Lernens" SB Creative, 2019
Recommended Posts