[JS]
[DE]
[USE] plot
[PLUGIN] ml.plugin
[PLUGIN] math.plugin
[PLUGIN] popup.plugin
[PLUGIN] R.plugin
[PLUGIN] file.plugin
[PLUGIN] help.plugin
[PLUGIN] button.plugin
[TITLE] R - Einführung in ML mit ANN (1)
[AUTHOR] Stefan Bosse
[VERSION] 12.2023

# Einführung in Einführung in ML mit ANN

[FUN]
```js
Plot.create=function (data,options) { console.log(options); drawPlot(0,Plot(data,options))}
new HelpUI({
  welcome:'Enter search pattern (with optional wildcards *)',
  label:'HelpBot',
  callback:function (text) {
    var result = R.help(text)
    return result?result:'Sorry, found nothing helpful.'
  }
})
```

[TOC]

## Vorwort

Bitte folgenden Code ausführen um notwendige Bibliotheken zu laden. Nicht erforderlich bei nativer R Software.

>! Der Code in dieser Übung wird in einem eigenen Web Worker Prozess unabhängig von der Frontend Seite ausgeführt. Daher muss der Worker zuerst EINMAL gestartet werden.

[R] R Worker Starten { lines:5; height:4 }
```R
install.packages(["math","ml"])
worker()
```

[R] R Set-up { lines:5; height:5 }
```R
use math,plot,ann
dev.new(width=500)
print("Libraries opened.")
print(R.version)
options(digits=3)
```

>! Es wird in diesem Kurs der R-Dialekt r+ verwendet. R+ ist eine Reimplementierung von R in JavaScript und läuft direkt in Web Browsern und node webkit Applikationsprogrammen. Es ist keine Softwareinstallation erforderlich.

- R+ ist nahezu R Syntax mit einigen Ergänzungen die die Programmierung und lesbarkeit von Programmen erleichtern.

- Nicht alle R Packages sind in R+ enthalten, und es kann Abweichungen geben. Hier werden vor allem das *math*, und *ann* Package verwendet.

- Dennoch lassen sich die meisten öffentlich verfügbaren algorithmischen Lösungen und Hilfestellungen mit R+ umsetzen.

## Das Künstliche Neuronale Netzwerk

Es gibt verschiedene KNN (ANN) Pakete in R. "Neuralnt" ist ein solches in R programmiertes Paket. Es bietet moderne Trainingsalgorithmen wie "resilent backpropagation" (rprop). Alternativ gibt es auch Schnittstellen zu bekannten Frameworks wie TensorFlow oder Keras. Hier wird ein vereinfachtes ANN Paket verwendet. Es bietet klassische gradientenbasierte Fehlerückpropagation.

Das ANN Modell läßt sich durch folgende Parameter definieren:

1. Statische Parameter: Die Graphstruktur, d.h. die Anzahl der Schichten und Neuronen sowie ihre Verbindungen;
2. Dynamische Parameter: Alle funktionalen Parameter wie Geichte und Bias.

>! Auch die Architektur (statisch) kann prinzipiell beim Training verändert werden. Zum einen gibt es Graphenreduktion, zum anderen kann mit genetischen/evolutionäre Algorithmen auch die Strutkur während des Trainings angepasst werden.

## Training

Das Training soll die dynamischen Parameter des Modell derart anpassen dass der gesamte Modellfehler *y*~0~-*y* minimal wird (Optimierunsgproblem). Diese Optimierungsprobleme sind häufig mit gradientenbasierten Verfahren gelöst werden.

Vereinfacht verwendet man den aktuellen Modellfehler *x* → *y*: *E*=*y*-*y*~0~ um die Gewichte und den Offset (bias) der einzelnen Funktionsknoten anzupassen:

$
%%ascii
w´_i = w_i - alpha (y-y_0) x_i
b´_i = b_i - alpha (y-y_0)
$

[R] Ein einfaches ANN mit zwei Eingabe- und einer Ausgabevariable { lines:20; height:20 }
```R
function sigmoid(x) {
  1/(1+exp(-x))
}
plot(x=seq(-10,10),y=sigmoid(seq(-10,10)),type='line')
```

[R] Ein einfaches ANN mit zwei Eingabe- und einer Ausgabevariable { lines:5; height:20 }
```R
function neuron(x1,x2,w,b) {
  accu = x1*w[1]+x2*w[2]
  sigmoid(accu+b)  
}
```

[QUESTION]
Welche Eigenschaft besitzt die Sigmoid Funktion im Vergleich zu einem Polynom?

[INPUT]

[R] Let's train  { lines:20; height:20 }
```R
data = {
  {x1=0,  x2=0,  y=0},  
  {x1=1,  x2=0,  y=0.3},  
  {x1=0,  x2=1,  y=0.5},  
  {x1=1,  x2=1,  y=1}  
}
w = [0,0] b=0 samples=1:4 
rate=0.01 epochs=1000
for (run in 1:epochs) {
  set=sample(samples,1)
  row=data[[set]]
  y=neuron(row$x1,row$x2,w,b)
  err=y-row$y
  w[1]=w[1]-rate*err*row$x1
  w[2]=w[2]-rate*err*row$x2
  b=b-rate*err
}
print(w) print(b)
```
[R] Let's test  { lines:20; height:20 }
```R
for (index in 1:4) {
  row=data[[index]]
  y=neuron(row$x1,row$x2,w,b)
  print(paste('Index',index,'Predicted',y,'Error',y-row$y))
}
```

[TODO]
Verändere die Lernrate, die Anzahl der Epochen, und die Startwerte der Parameter. Notiere einige Ergebnisse und Beobachtungen. Was passiert wenn die Lernrate zu groß gewählt wird?

[INPUT]

## Das EXOR Problem

[R] Ein einfaches ANN mit einer Eingabe, einer Ausgabe, und inneren Schichten (oder keine) für eine Klassifikation (0/1) { lines:20; height:20 }
```R
data = data.frame(
  x1=[0,1,0,1],
  x2=[0,0,1,1],
  y =[0,1,1,0]
)
model.ann = ann::ann([2,2,1])
result = train(model.ann,data,
               formula=y~x1+x2,
               epochs=100,
               rate=0.4)
print(result)
result = predict(model.ann,data[,1:2])
print(result)
```

[TODO]
Variiere die Trainingsparamter (*rate*,*epochs*) und berichte über die Ergebnisse. Wichtig: jeder Traingslauf startet mit einer randomisierten Initialisierung der Gewichte der Neuronen. Ergebnisse können daher varaiieren. Dann variiere die inneren Schichten (oder lasse sie weg). Wie ändern sich die Ergebnisse?

[INPUT]

## Funktionsregression

Neben der Klassifikation durch approximkierte binäre Ausgänge des netzwerks (typisch ein Neuron pro Klasse) kann man mit ANN auch eine Funktionsregression implementieren. Nachfolgend ist das für die Approximation der Sinusfunktion (erster Quadrant) gezeigt.

[R] Ein einfaches ANN mit einer Eingabe, einer Ausgabe, und inneren Schichten (oder keine) für eine Funktionsregression  { lines:20; height:20 }
```R
use plot
x = 1:100
y = sin(x/(20*3.14))
data2=data.frame(x=x/100,y=y)
plot(y,type='line')
model.ann2 = ann([1,4,4,1])
result = train(model.ann2,data2,
               formula=y~x,
               epochs=100,
               rate=0.1)
print(result)
yp=predict(model.ann2,data.frame(x=x/100))
yp=yp[,1]
plot({yp=yp,y=y},type='line')
```

[TODO]
Variiere die Trainingsparamter (*rate*,*epochs*) und berichte über die Ergebnisse. Wichtig: jeder Traingslauf startet mit einer randomisierten Initialisierung der Gewichte der Neuron. Ergebnisse können daher varaiieren. Dann variiere die inneren Schichten (oder lasse sie weg). Wie ändern sich die Ergebnisse? Berechne jeweils den mittleren Fehler (`abs(yp-y)/length(y)`).

[INPUT]

## Einblicke

Ein ANN ist ein "Black Box" Modell. Es setzt sich aus i.A. aus einer Vielzahl von nicht linearen Funktionen zusammen und bildet eine "Meta" Funktion deren Übertragungsfunktion der gewünschten *x* → *y* Abbildung angenähert ist. Um Einblicke in das Verhalten von ANN (ind anderen komplexen ML Modellen) zu erhalten kann man sich z.B. die Ausgänge der Teilfunktionen für eine gegebene Aktivierung (*x*) anschauen.

[R] Darstellung der Ausgabe  der einzelnen Schichten des ANN Modells für eine bestimmte Aktivierung *x*  { lines:20; height:20 }
```R
for(j in [1,20,90]) {
  print(paste('x',j,x[j]))
  predict(model.ann2,[x[j]])
  for (i in 1:4) {
    print(paste('Layer',i,sense(model.ann2,i,'output')))
  }
  print('-----------')
}
```

[TODO]
Beobachte die Ausgaben für die Werte *x*[1], *x*[20], und *x*[90]. Wo liegen typischerweise die Ausgabewerte der inneren Neuronen? Betrachte die Sigmoid Funktion (Übertragungsbereich), was bedeutet das für die Nicht-Lineraität der Gesamtfunktion bzw. wie kommt sie zu stande?

[INPUT]

[BUTTON] Hilfe { action:post; label:Absenden; style:"color:red" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['Name','Email','Pin','Frage'],
  email:{from:'$Email', to:'sbosse@uni-bremen.de', name:'$Name'},
  subject:'Hilfe Kurs ML $TITLE',
  message:'$Name: $Frage',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:1827,
}
```

[BUTTON] Einreichung (Assignment #01-46158 ) { action:post; label:Absenden; style:"color:green" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['Name','Email','Pin','Kommentar'],
  submit: { from:'$Email', to:'sbosse@uni-bremen.de' },
  assignment:'01-46158',
  name : '$Name',
  comment : '$Kommentar',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:1827,
}
```

[BUTTON] Prüfen { action:post; label:Laden; style:"color:browm" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['ID','Pin'],
  load: { id:'$ID' },
  pin:[1827,9223],
}
```

[BUTTON] Bewerten (Lehrer) { action:post; label:Absenden; style:"color:blue" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['ID','Marking','Pin','Remarks'],
  submit: { id:'$ID', from:'sbosse@uni-bremen.de', name:'$Name' },
  marks : '$Marking',
  remarks : '$Remarks',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:9223,
}
```

---

Einführung in Einführung in ML mit ANN

Inhalt.

Einführung in Einführung in ML mit ANN

Vorwort

Das Künstliche Neuronale Netzwerk

Training

Das EXOR Problem

Funktionsregression

Einblicke

Vorwort

Bitte folgenden Code ausführen um notwendige Bibliotheken zu laden. Nicht erforderlich bei nativer R Software.

Der Code in dieser Übung wird in einem eigenen Web Worker Prozess unabhängig von der Frontend Seite ausgeführt. Daher muss der Worker zuerst EINMAL gestartet werden.

R Worker Starten

install.packages(["math","ml"])
worker()

▸

[]

✗

≡

R Set-up

use math,plot,ann
dev.new(width=500)
print("Libraries opened.")
print(R.version)
options(digits=3)

▸

[]

✗

≡

Es wird in diesem Kurs der R-Dialekt r+ verwendet. R+ ist eine Reimplementierung von R in JavaScript und läuft direkt in Web Browsern und node webkit Applikationsprogrammen. Es ist keine Softwareinstallation erforderlich.

R+ ist nahezu R Syntax mit einigen Ergänzungen die die Programmierung und lesbarkeit von Programmen erleichtern.
Nicht alle R Packages sind in R+ enthalten, und es kann Abweichungen geben. Hier werden vor allem das math, und ann Package verwendet.
Dennoch lassen sich die meisten öffentlich verfügbaren algorithmischen Lösungen und Hilfestellungen mit R+ umsetzen.

Das Künstliche Neuronale Netzwerk

Das ANN Modell läßt sich durch folgende Parameter definieren:

Statische Parameter: Die Graphstruktur, d.h. die Anzahl der Schichten und Neuronen sowie ihre Verbindungen;
Dynamische Parameter: Alle funktionalen Parameter wie Geichte und Bias.

Auch die Architektur (statisch) kann prinzipiell beim Training verändert werden. Zum einen gibt es Graphenreduktion, zum anderen kann mit genetischen/evolutionäre Algorithmen auch die Strutkur während des Trainings angepasst werden.

Training

Das Training soll die dynamischen Parameter des Modell derart anpassen dass der gesamte Modellfehler y₀-y minimal wird (Optimierunsgproblem). Diese Optimierungsprobleme sind häufig mit gradientenbasierten Verfahren gelöst werden.

Vereinfacht verwendet man den aktuellen Modellfehler x → y: E=y-y₀ um die Gewichte und den Offset (bias) der einzelnen Funktionsknoten anzupassen:

\[ {w}´_{{i}}={w}_{{i}}-\alpha{\left({y}-{y}_{{0}}\right)}{x}_{{i}}\\ {b}´_{{i}}={b}_{{i}}-\alpha{\left({y}-{y}_{{0}}\right)} \]

Ein einfaches ANN mit zwei Eingabe- und einer Ausgabevariable

function sigmoid(x) {
  1/(1+exp(-x))
}
plot(x=seq(-10,10),y=sigmoid(seq(-10,10)),type='line')

▸

[]

✗

≡

Ein einfaches ANN mit zwei Eingabe- und einer Ausgabevariable

function neuron(x1,x2,w,b) {
  accu = x1*w[1]+x2*w[2]
  sigmoid(accu+b)  
}

▸

[]

✗

≡

Frage. Welche Eigenschaft besitzt die Sigmoid Funktion im Vergleich zu einem Polynom?

Let's train

data = {
  {x1=0,  x2=0,  y=0},  
  {x1=1,  x2=0,  y=0.3},  
  {x1=0,  x2=1,  y=0.5},  
  {x1=1,  x2=1,  y=1}  
}
w = [0,0] b=0 samples=1:4 
rate=0.01 epochs=1000
for (run in 1:epochs) {
  set=sample(samples,1)
  row=data[[set]]
  y=neuron(row$x1,row$x2,w,b)
  err=y-row$y
  w[1]=w[1]-rate*err*row$x1
  w[2]=w[2]-rate*err*row$x2
  b=b-rate*err
}
print(w) print(b)

▸

[]

✗

≡

Let's test

for (index in 1:4) {
  row=data[[index]]
  y=neuron(row$x1,row$x2,w,b)
  print(paste('Index',index,'Predicted',y,'Error',y-row$y))
}

▸

[]

✗

≡

Aufgabe. Verändere die Lernrate, die Anzahl der Epochen, und die Startwerte der Parameter. Notiere einige Ergebnisse und Beobachtungen. Was passiert wenn die Lernrate zu groß gewählt wird?

Das EXOR Problem

Ein einfaches ANN mit einer Eingabe, einer Ausgabe, und inneren Schichten (oder keine) für eine Klassifikation (0/1)

data = data.frame(
  x1=[0,1,0,1],
  x2=[0,0,1,1],
  y =[0,1,1,0]
)
model.ann = ann::ann([2,2,1])
result = train(model.ann,data,
               formula=y~x1+x2,
               epochs=100,
               rate=0.4)
print(result)
result = predict(model.ann,data[,1:2])
print(result)

▸

[]

✗

≡

Aufgabe. Variiere die Trainingsparamter (rate,epochs) und berichte über die Ergebnisse. Wichtig: jeder Traingslauf startet mit einer randomisierten Initialisierung der Gewichte der Neuronen. Ergebnisse können daher varaiieren. Dann variiere die inneren Schichten (oder lasse sie weg). Wie ändern sich die Ergebnisse?

Funktionsregression

Ein einfaches ANN mit einer Eingabe, einer Ausgabe, und inneren Schichten (oder keine) für eine Funktionsregression

use plot
x = 1:100
y = sin(x/(20*3.14))
data2=data.frame(x=x/100,y=y)
plot(y,type='line')
model.ann2 = ann([1,4,4,1])
result = train(model.ann2,data2,
               formula=y~x,
               epochs=100,
               rate=0.1)
print(result)
yp=predict(model.ann2,data.frame(x=x/100))
yp=yp[,1]
plot({yp=yp,y=y},type='line')

▸

[]

✗

≡

Aufgabe. Variiere die Trainingsparamter (rate,epochs) und berichte über die Ergebnisse. Wichtig: jeder Traingslauf startet mit einer randomisierten Initialisierung der Gewichte der Neuron. Ergebnisse können daher varaiieren. Dann variiere die inneren Schichten (oder lasse sie weg). Wie ändern sich die Ergebnisse? Berechne jeweils den mittleren Fehler (abs(yp-y)/length(y)).

Einblicke

Ein ANN ist ein "Black Box" Modell. Es setzt sich aus i.A. aus einer Vielzahl von nicht linearen Funktionen zusammen und bildet eine "Meta" Funktion deren Übertragungsfunktion der gewünschten x → y Abbildung angenähert ist. Um Einblicke in das Verhalten von ANN (ind anderen komplexen ML Modellen) zu erhalten kann man sich z.B. die Ausgänge der Teilfunktionen für eine gegebene Aktivierung (x) anschauen.

Darstellung der Ausgabe der einzelnen Schichten des ANN Modells für eine bestimmte Aktivierung x

for(j in [1,20,90]) {
  print(paste('x',j,x[j]))
  predict(model.ann2,[x[j]])
  for (i in 1:4) {
    print(paste('Layer',i,sense(model.ann2,i,'output')))
  }
  print('-----------')
}

▸

[]

✗

≡

Aufgabe. Beobachte die Ausgaben für die Werte x[1], x[20], und x[90]. Wo liegen typischerweise die Ausgabewerte der inneren Neuronen? Betrachte die Sigmoid Funktion (Übertragungsbereich), was bedeutet das für die Nicht-Lineraität der Gesamtfunktion bzw. wie kommt sie zu stande?

Hilfe

Einreichung (Assignment #01-46158 )

Prüfen

Bewerten (Lehrer)

Created by the NoteBook Compiler Ver. 1.25.0 (c) Dr. Stefan Bosse (Tue Dec 19 2023 16:26:51 GMT+0100 (Central European Standard Time))