Simpler konstruierter Fall für unser Beispiel; absolut linear; hier würde einfach DM/Euro ausreichen, was die Maschine aber nicht wissen kann
Normales Problem für lineare Regression
import pandas as pd
df = pd.read_csv('Euro_DM.csv', index_col='Unnamed: 0')
df.head()
| EURO | DM | |
|---|---|---|
| 1 | 3 | 5.86749 |
| 2 | 5 | 9.77915 |
| 3 | 6 | 11.73498 |
| 4 | 8 | 15.64664 |
| 5 | 12 | 23.46996 |
Wir wissen: Euro * 1,95583 ist der Umrechnungsfaktor für DM
Aber die Maschine nicht ;-)
Simpler konstruierter Fall für unser Beispiel; absolut linear; hier würde einfach DM/Euro ausreichen, was die Maschine aber nicht wissen kann
Normales Problem für lineare Regression
Maschinen berechnen die Differenz zwischen dem Ziel (hier DM) und einer Vorhersage
Vorhersage ist : f(x) = x * w + b
x ist hier unser Euro Wert
w ist ein Gewicht, welches es für die Maschine herauszufinden gilt, es bestimmt die Steigung der Funktion, also wie steil 𝑓 ( 𝑥 ) in Abhängigkeit von 𝑥 ansteigt oder abfällt.
b ist ein konstanter Wert, genannt Bias, welchen die Maschine ebenfalls ermitteln muss, er verschiebt die gesamte Funktion entlang der y-Achse nach oben oder unten.
Die Differenz ergibt sich aus dem (Ziel(DM) - (Vorhersage(x * w + b))
Dann bilden sie daraus den quadratischen Fehler : (DM - (x * w + b))²
Diesen Fehler versuchen sie soweit als möglich zu reduzieren und bedienen sich hier der partiellen Ableitungen für die quadratische Funktion.
Diese berechnet die Steigung für unsere Funktion und ist somit geeignet, als Maß für die Reduzierung des Fehlers zu dienen.
Simples Gradienten Abstiegsverfahren manuell implemetiert; Beispiel lineare Regression mit einem Feature und einem Target
# Wir belegen unser Feature x und unser Target y
x = df['EURO'].astype(float).reset_index(drop=True)
y = df['DM'].astype(float).reset_index(drop=True)
'''
Optimizer Funktion
Update der Gewichte und des Bias für ein eindimensionales x-Array.
Parameter: Feature x[n], Target y[n], Gewicht w, Bias b, Lernrate alpha.
y_predict = (w*x[i] + b)
quadrierter_fehler = (y[i] - y_predict)²
Ableitung der Funktion nach w: 2x*(y[i] - (w*x[i] + b))
Ableitung der Funktion nach b: 2*(y[i] - (w*x[i] + b))
'''
def ralfs_optimizer(x, y, w, b, alpha):
sw = 0.0
sb = 0.0
for i in range(len(x)):
sw += 2*x[i]*(y[i] - (w*x[i] + b)) # Summenbildung Steigung für x
sb += 2*(y[i] - (w*x[i] + b)) # Summenbildung Steigung für Bias
# neues Gewicht w und neuen Bias b berechnen
w += (sw/len(x) *alpha) # altes Gewicht plus durschnittlicher Wert der Gradienten-Summe sw mal Lernrate
b += (sb/len(x) *alpha) # alter Bias plus durschnittlicher Wert des Bias-Gradienten sb mal Lernrate
#### für dieses Beispiel eines sehr einfachen, völlig linearen Falls benötigen wir keinen Bias,
#### also lasse ich ihn hier weg und bleibe bei 0.0
b = 0.0
return w, b
def avg_loss(x, y, w, b):
total_error = 0.0
for i in range(len(x)):
total_error += (y[i] - (w*x[i] + b))**2
return total_error / len(x)
import numpy as np
import matplotlib.pyplot as plt
def fit(x, y, epochs, optimizer, w = 0.0, b = 0.0, alpha = 0.00001 ):
for e in range(epochs+1):
w, b = optimizer(x, y, w, b, alpha)
''' ab hier reine Ausgabe '''
image_counter = 1
# Ausgabe des aktuellen loss der Epoche
# Plus Ausgabe als Plot
if (e == 0) or (e < 21 and e % 4 == 0) or (e >= 30 and e % 10 == 0) or (e == epochs):
print("epoche: ", str(e), "loss: "+ '%.10f'%(avg_loss(x,