[JS]
[DE]
[USE] plot
[USE] graph
[PLUGIN] ml.plugin
[PLUGIN] math.plugin
[PLUGIN] popup.plugin
[PLUGIN] R.plugin
[PLUGIN] file.plugin
[PLUGIN] button.plugin
[PLUGIN] help.plugin

[TITLE] Zustandsbasierte Künstliche Neuronale Netzwerke für Datenserienpädiktion
[AUTHOR] Stefan Bosse
[VERSION] 7.2024

# Übung 7 - Zustandsbasierte Künstliche Neuronale Netzwerke für Datenserienpädiktion

[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 (außer "entropy").

>! Es kann ein Hintergrundprozess gestartet werden (hier WebWorker). Dazu die folgende Zeile mit dem Worker Code auskommentieren.

[R] R Set-up { lines:10; height:10 }
```R
install.packages(['math','ml'])
use math,plot
print(paste("R version",R.version))
dev.new(width=500)
options(digits=2)
print("Libraries loaded.")
# worker({data.tt=data.tt})
```

## LSTM

- In dieser Übung wird das *neataptic* Software Framework verwendet. Es enthält generische und spezielle Modelle von Künstliche Neuronale Netzwerken.

https://wagenaartje.github.io/neataptic/

- Eine Long-short-term Memory Zellen (LSTM) Modell ist ein zustandsbasiertes Modell, d.h. es speichert Werte aus vorherigen Berechnungen.

- Eine LSTM Zelle besteht aus mehreren Funktionen. Neben der Speicherzelle (*C*) gibt es Hilfszellen die den Einfluss der Vergangenheit und der zukünftigen Entwicklung des Zustandes und des Ausgabewertes bestimmen.

- Die Hilfszellen steuern Gatter (quasi Ventile) die Rückkopplung und Abklingen der Speicherzelle bestimmen. Weiterhin gibt es Gatter die LSTM Zellen vertikal (also in einer Schicht) verbinden können.

Nachfolgend ist der schematische Aufbau einer LSTM Zelle gezeigt.

![#lstmcell width=60%](images/lstm.png)

## Zeit- und Datenserien

Ein Datenserie ist durch einen *x* und *y*(*x*) Vektor bestimmt. Datenserien können ein- oder mehrdimensional sein (dann Vektoren von Vektoren oder Matrizen).

$
%%ascii
vec x = { x_1,x_2,..,x_n }
vec y(vec x) = { y_1,y_2,...,y_n }
$

Dabei sind die x- und y-Werte geordnet, und *x* kann auch eine Zeitvariable sein. Bei Zugversuchen ist *x* häufig die Messung der Dehnung und *y* die resultierende Kraft.

- Beispiele für Datenserien können wir uns mit trigonometrischen Funktionen erzeugen, z.B. die Sinus Funktion oder eine mit einer Gauß-Funktion maskierte Sinusfunktion ("Chirp" Signal)

[R] Zusammenfassung der Datensätze  { lines:15; height:15 }
```R
use math,signal,plot
N=1000
data.x = seq(1,N)
data.sin.y = sin(data.x/10)/2+0.5
data.cos.y = cos(data.x/10)/2+0.5
data.chirp.y = chirp(N,50,300,80)/2+0.5
plot(data.x,
     {sin=data.sin.y,cos=data.cos.y,chirp=data.chirp.y},
     type='l')
```

>! Datenserienprädiktion ist i.A. ein sequenzieller und datenstrombasierter Prozess.

- Ein LSTM Modell bekommt als Eingabe schrittweise sequenziell neue Eingabewerte *x* oder als Datenserienvektor **x**.

- Die Ausgabe ist entweder die Prädiktion künftiger Werte (Entwicklungsprogonose einer Datenserie) oder eine andere Eigenschaftsavriable (z.B. Anomaliedetektor).

## LSTM Modell

[R] LSTM Modell für skalare Eingabe- und Ausgabewerte  { lines:15; height:15 }
```R
use ann
model.lstm = ann([1,4,4,1],architect="lstm",details={
  memoryToMemory=FALSE,
  outputToMemory=TRUE,
  outputToGates=FALSE,
  inputToOutput=TRUE,
  inputToDeep=TRUE
},activations=['relu','tanh','tanh','relu'])
print(summary(model.lstm))
```
Das Modell enthält eine Eingabe- und Ausgabeschicht (jeweils 1 Neuron). Die inneren Schichten sind LSTM Zellen (hier zwei hintereinander geschaltete Schichten mit jeweils 4 LSTM Zellen).

- Die *details* Liste beschreibt innere Verschaltung der LSTM Zellen.
- Der *activations* Vektor legt für jede Schicht die Aktivierungsfunktion fest.

## Die Daten (Signale)

>@ Zunächst soll eine Zukunftsvorhersage um δ Schritte eines Signals erfolgen.

- Dazu müssen Trainingsdaten erzeugt werden. Dazu nimmt man das Signal und verschiebt es.
- Die Chirp Funktion hat einen Offset, jedoch verschiebt dieser nur die Gaußsche Fenstermaske, und liefert bei einem anderen Offset ein anderes Signals (Die Basisschwingung bleibt ja die gleiche). Aber warum nicht fürs Training verwenden, wir wollen ja nicht die Identitätsfunktion lernen...

[R] Daten (1)  { lines:15; height:15 }
```R
use math,signal,plot
N=1000
delta=30
data.x = seq(1,N)
data.chirp.y = chirp(N,50,300,80)/2+0.5
data.chirp.y.o30 = chirp(N,50,300+delta,80)/2+0.5
data.chirp.y.d30 = vector(length(data.chirp.y),value=0.5)
data.chirp.y.d30[(200+delta):(600+delta)]=data.chirp.y[200:600]

plot(data.x,
     {y=data.chirp.y,y.d30=data.chirp.y.d30,y.o30=data.chirp.y.o30},
     type='l')
```

## Das Training (Signale)

- Die Lernrate sollte klein gewählt werden (< 0.05)
- Es reichen häufig 100-300 Epochen - wenn nicht ist das Problem mit dem Modell nicht oder nur schwer trainierbar

[R] Training (1)  { lines:15; height:15 }
```R
use ann
train(model.lstm,
      data.chirp.y,data.chirp.y.o30,
      epochs=100,rate=0.05)
```

## Der Test (Signale)

- Jetzt wird das ursprüngliche Signal wieder eingegeben und ein Vergleich mit dem verschobenen Signal gemacht (jetzt echte Verschiebung)

[R] Test (1)  { lines:15; height:15 }
```R
use ann,plot
plot(data.x,{
  y.o30  = data.chirp.y.o30,
  y0  = data.chirp.y,
  yp = predict(model.lstm,data.chirp.y)
},type='l')
```

## Die Daten (Zugversuch)

Der Datensatz besteht aus 42 Zugversuchen unbekannter Herkunft.

- Es gibt pro Versuch einen x- und einen y-Vektor.
- Der x-Vektor ist die gemessene Dehnung (Weg)
- Der y-Vektor ist die gemessene Kraft (Spannung)

[DATA] dataTT:data/tt-dataXY.json

[FUN]
```js
console.log(dataTT)
R.addValue('data.tt',{
  type : 'data.frame',
  nrow : dataTT.length,
  ncol : 2,
  colnames : ['x','y'],
  value : dataTT.map((row) => ([row.map(xy => xy[0]),row.map(xy=>xy[1])]))
})
```
[R] Zusammenfassung des TT Datensatzes  { lines:15; height:15 }
```R
use math,plot
print("============== data.tt ====================")
print(paste("nrow",nrow(data.tt),"ncol",ncol(data.tt)))
print(paste("colnames",colnames(data.tt)))
print(summary(data.tt))
plot(data.tt[1,]$x,data.tt[1,]$y,type='l')
```

![#zugversuchskurve width=60%](images/Zugpruefung_Diagramm_mit_Dehngrenzen.png)

https://www.schuetz-licht.de/wissen-normen-seminare/zugversuch

[QUESTION] 
Finde anhand der Kurvenplots heraus um welche Materialklasse es sich handeln könnte. Gibt es unterschiedliche Subklassen?

[INPUT]

[R] Alle Kurven des TT Datensatzes  { lines:30; height:15 }
```R
use math,plot
for(index in 1:nrow(data.tt)) {
  plot(data.tt[index,]$x,data.tt[index,]$y,main='Index '+index,type='l') 
}
```

Hilfe:

![#zugversuchskurvenmat width=60%](images/tt_mat_classes.png)

https://www.smlease.com/entries/mechanical-design-basics/stress-strain-curve-diagram/

>! Aber Halt: Wir haben ein Problem mit diesen eigentlich zweidimensionalen Daten. *y* (also die Kraft/Spannung) hängt von *x* (also der Dehnung) ab. Unsere Modelle verarbeiten momentan aber nur skalare Größen und vor allem sollten die Werte der Datenserie äquidistant (mit Bezug z.B. zur Zeit oder hier der Dehnung) sein.

[R] Darstellung des TT Datensatzes  { lines:15; height:15 }
```R
plot(data.tt[1,]$x,data.tt[1,]$y,type='l')
plot(data.tt[1,]$y,type='l')
```

- Daher muss die Datenserie linearisiert werden.
- Dazu wird ein linearisierter x-Vektor erzeugt (also mit äquidistanten Δx) und y-Werte gesucht die ein x-Wert mit kleinsten Abstand besitzen.
- Weiterhin muss die Datenserie normalisiert werden. Bei Verwendung von sigmoid/logistik Aktivierungsfunktionen ist ein Bereich (0,1) ohne o/u Grenzen erforderlich.

[QUESTION]
Wie ist das Delta (*delta*, Verschiebung) zu wählen? Das Delta bestimmt die Recihweite bei der Prognose eines Zukunftswertes.

[INPUT]

[R] Linarisierung und Normalisierung des TT Datensatzes  { lines:20; height:15 }
```R
use  plot
delta=5
delta.x=0.002
function linearize(xs,ys) {
  xe=seq(0,0.5,delta.x)
  ye=vector(length(xe))
  i=1
  j=1
  for(x in xe) {
    for(k in i:length(xs)) {
       if (xs[k]>=x) {
         # print(j)
         ye[j]=ys[k]
         j=incr(j)
         i=k
         break
       }
    }
  }
  ye
}
data.tt.y = list()
data.tt.y.d = list()
for(index in 1:nrow(data.tt)) {
  xs=data.tt[index,]$x
  ys=data.tt[index,]$y
  ye=linearize(xs,ys)/5000
  n=length(ye)
  yd=vector(n)
  yd[1:(n-delta)]=ye[delta:n]
  push(data.tt.y,ye)
  push(data.tt.y.d,yd)
}
logg(typeof(data.tt.y))
plot({y=data.tt.y[[1]],yd=data.tt.y.d[[1]]},type='l')
```

## Randomisierung

Die Datensätze besitzen och eine Ordnung (welche auch immer, Experimentreihenfolge, Gruppen von Materialien usw.).

- Daher ist eine Randomisierung der Reihenfolge der Datensätze für das Training erforderlich.
- jetzt haben wir aber schon zwei Tabellen: 
  + *data.tt.y* mit originalen aber linearisierten y-Daten
  + *data.tt.y.d* mit den um δ verschobenen Datenserien (für das Training)
- Daher wird ein randomisierter Indexvektor erzeugt, der gleichermaßen auf beiden Tabellen (Listen) angewendet wird und neu (randomisiert) angeordnete Listen erzeugt.

[R] Randomisierung des TT Datensatzes  { lines:20; height:15 }
```R
use plot
index=seq(1,nrow(data.tt))
index=sample(index)
data.tt.y=data.tt.y[index]
data.tt.y.d=data.tt.y.d[index]
logg(typeof(data.tt.y))
plot({y=data.tt.y[[1]],yd=data.tt.y.d[[1]]},type='l')
```
## LSTM Modell

[R] LSTM Modell für Vorhersage von Zugversuchskurven  { lines:15; height:15 }
```R
use ann
model.lstm = ann([1,4,4,1],architect="lstm",details={
  memoryToMemory=FALSE,
  outputToMemory=TRUE,
  outputToGates=FALSE,
  inputToOutput=TRUE,
  inputToDeep=TRUE
},activations=['relu','tanh','tanh','relu'])
print(summary(model.lstm))
```

[QUESTION]
Welche Punkt (welche Punkte) der Zugversuchskurve sollte vorhergesagt werden?

[INPUT]

## LSTM Training (Zugversuch)

Hier wird das Modell iterative mit allen Datenserien trainiert. Je nach Serie wird es unterschiedliche Fehler geben.

- Ob sich eine Konvergenz einstellt ist unbestimmt (d.h. generalisiertes Modell vs. spezielles)
- Die Trainingsschleife kann mehrfach wiederholt werden. Nach jedem Schleifendurchlauf einen Test durchführen.

[R] Iteratives Training des LSTM Modells mit Instanzen des TT Datensatzes  { lines:20; height:15 }
```R
use ann
for(index in 1:length(data.tt.y)) {
  result=train(model.lstm,data.tt.y[[index]],
                          data.tt.y.d[[index]],
                          epochs=10,rate=0.01)
  result$index=index
  cprint(result)
}
```

## LSTM Test (Zugversuch)

[R] Test des LSTM Modells mit Instanzen des TT Datensatzes  { lines:20; height:15 }
```R
index=11
plot({y=data.tt.y[[index]],
       y.d=data.tt.y.d[[index]],
       yp=predict(model.lstm,data.tt.y[[index]])
       },type='l')
```

[QUESTION]
Kann der Übergang vom elastischen zum plastischen Bereich vorhergesagt werden?

[INPUT]

Übung 7 - Zustandsbasierte Künstliche Neuronale Netzwerke für Datenserienpädiktion

Inhalt.

Übung 7 - Zustandsbasierte Künstliche Neuronale Netzwerke für Datenserienpädiktion

Vorwort

LSTM

Zeit- und Datenserien

LSTM Modell

Die Daten (Signale)

Das Training (Signale)

Der Test (Signale)

Die Daten (Zugversuch)

Randomisierung

LSTM Modell

LSTM Training (Zugversuch)

LSTM Test (Zugversuch)

Vorwort

Bitte folgenden Code ausführen um notwendige Bibliotheken zu laden. Nicht erforderlich bei nativer R Software (außer "entropy").

Es kann ein Hintergrundprozess gestartet werden (hier WebWorker). Dazu die folgende Zeile mit dem Worker Code auskommentieren.

R Set-up

install.packages(['math','ml'])
use math,plot
print(paste("R version",R.version))
dev.new(width=500)
options(digits=2)
print("Libraries loaded.")
# worker({data.tt=data.tt})

▸

[]

✗

≡

LSTM

In dieser Übung wird das neataptic Software Framework verwendet. Es enthält generische und spezielle Modelle von Künstliche Neuronale Netzwerken.

https://wagenaartje.github.io/neataptic/

Eine Long-short-term Memory Zellen (LSTM) Modell ist ein zustandsbasiertes Modell, d.h. es speichert Werte aus vorherigen Berechnungen.
Eine LSTM Zelle besteht aus mehreren Funktionen. Neben der Speicherzelle (C) gibt es Hilfszellen die den Einfluss der Vergangenheit und der zukünftigen Entwicklung des Zustandes und des Ausgabewertes bestimmen.
Die Hilfszellen steuern Gatter (quasi Ventile) die Rückkopplung und Abklingen der Speicherzelle bestimmen. Weiterhin gibt es Gatter die LSTM Zellen vertikal (also in einer Schicht) verbinden können.

Nachfolgend ist der schematische Aufbau einer LSTM Zelle gezeigt.

#lstmcell

Zeit- und Datenserien

Ein Datenserie ist durch einen x und y(x) Vektor bestimmt. Datenserien können ein- oder mehrdimensional sein (dann Vektoren von Vektoren oder Matrizen).

\[ \vec{{x}}={\left\lbrace{x}_{{1}},{x}_{{2}},..,{x}_{{n}}\right\rbrace}\\ \vec{{y}}{\left(\vec{{x}}\right)}={\left\lbrace{y}_{{1}},{y}_{{2}},\ldots,{y}_{{n}}\right\rbrace} \]

Dabei sind die x- und y-Werte geordnet, und x kann auch eine Zeitvariable sein. Bei Zugversuchen ist x häufig die Messung der Dehnung und y die resultierende Kraft.

Beispiele für Datenserien können wir uns mit trigonometrischen Funktionen erzeugen, z.B. die Sinus Funktion oder eine mit einer Gauß-Funktion maskierte Sinusfunktion ("Chirp" Signal)

Zusammenfassung der Datensätze

use math,signal,plot
N=1000
data.x = seq(1,N)
data.sin.y = sin(data.x/10)/2+0.5
data.cos.y = cos(data.x/10)/2+0.5
data.chirp.y = chirp(N,50,300,80)/2+0.5
plot(data.x,
     {sin=data.sin.y,cos=data.cos.y,chirp=data.chirp.y},
     type='l')

▸

[]

✗

≡

Datenserienprädiktion ist i.A. ein sequenzieller und datenstrombasierter Prozess.

Ein LSTM Modell bekommt als Eingabe schrittweise sequenziell neue Eingabewerte x oder als Datenserienvektor x.
Die Ausgabe ist entweder die Prädiktion künftiger Werte (Entwicklungsprogonose einer Datenserie) oder eine andere Eigenschaftsavriable (z.B. Anomaliedetektor).

LSTM Modell

LSTM Modell für skalare Eingabe- und Ausgabewerte

use ann
model.lstm = ann([1,4,4,1],architect="lstm",details={
  memoryToMemory=FALSE,
  outputToMemory=TRUE,
  outputToGates=FALSE,
  inputToOutput=TRUE,
  inputToDeep=TRUE
},activations=['relu','tanh','tanh','relu'])
print(summary(model.lstm))

▸

[]

✗

≡

Das Modell enthält eine Eingabe- und Ausgabeschicht (jeweils 1 Neuron). Die inneren Schichten sind LSTM Zellen (hier zwei hintereinander geschaltete Schichten mit jeweils 4 LSTM Zellen).

Die details Liste beschreibt innere Verschaltung der LSTM Zellen.
Der activations Vektor legt für jede Schicht die Aktivierungsfunktion fest.

Die Daten (Signale)

Zunächst soll eine Zukunftsvorhersage um δ Schritte eines Signals erfolgen.

Dazu müssen Trainingsdaten erzeugt werden. Dazu nimmt man das Signal und verschiebt es.
Die Chirp Funktion hat einen Offset, jedoch verschiebt dieser nur die Gaußsche Fenstermaske, und liefert bei einem anderen Offset ein anderes Signals (Die Basisschwingung bleibt ja die gleiche). Aber warum nicht fürs Training verwenden, wir wollen ja nicht die Identitätsfunktion lernen...

Daten (1)

use math,signal,plot
N=1000
delta=30
data.x = seq(1,N)
data.chirp.y = chirp(N,50,300,80)/2+0.5
data.chirp.y.o30 = chirp(N,50,300+delta,80)/2+0.5
data.chirp.y.d30 = vector(length(data.chirp.y),value=0.5)
data.chirp.y.d30[(200+delta):(600+delta)]=data.chirp.y[200:600]

plot(data.x,
     {y=data.chirp.y,y.d30=data.chirp.y.d30,y.o30=data.chirp.y.o30},
     type='l')

▸

[]

✗

≡

Das Training (Signale)

Die Lernrate sollte klein gewählt werden (< 0.05)
Es reichen häufig 100-300 Epochen - wenn nicht ist das Problem mit dem Modell nicht oder nur schwer trainierbar

Training (1)

use ann
train(model.lstm,
      data.chirp.y,data.chirp.y.o30,
      epochs=100,rate=0.05)

▸

[]

✗

≡

Der Test (Signale)

Jetzt wird das ursprüngliche Signal wieder eingegeben und ein Vergleich mit dem verschobenen Signal gemacht (jetzt echte Verschiebung)

Test (1)

use ann,plot
plot(data.x,{
  y.o30  = data.chirp.y.o30,
  y0  = data.chirp.y,
  yp = predict(model.lstm,data.chirp.y)
},type='l')

▸

[]

✗

≡

Die Daten (Zugversuch)

Der Datensatz besteht aus 42 Zugversuchen unbekannter Herkunft.

Es gibt pro Versuch einen x- und einen y-Vektor.
Der x-Vektor ist die gemessene Dehnung (Weg)
Der y-Vektor ist die gemessene Kraft (Spannung)

Zusammenfassung des TT Datensatzes

use math,plot
print("============== data.tt ====================")
print(paste("nrow",nrow(data.tt),"ncol",ncol(data.tt)))
print(paste("colnames",colnames(data.tt)))
print(summary(data.tt))
plot(data.tt[1,]$x,data.tt[1,]$y,type='l')

▸

[]

✗

≡

#zugversuchskurve

https://www.schuetz-licht.de/wissen-normen-seminare/zugversuch

Frage. Finde anhand der Kurvenplots heraus um welche Materialklasse es sich handeln könnte. Gibt es unterschiedliche Subklassen?

Alle Kurven des TT Datensatzes

use math,plot
for(index in 1:nrow(data.tt)) {
  plot(data.tt[index,]$x,data.tt[index,]$y,main='Index '+index,type='l') 
}

▸

[]

✗

≡

Hilfe:

#zugversuchskurvenmat

https://www.smlease.com/entries/mechanical-design-basics/stress-strain-curve-diagram/

Aber Halt: Wir haben ein Problem mit diesen eigentlich zweidimensionalen Daten. y (also die Kraft/Spannung) hängt von x (also der Dehnung) ab. Unsere Modelle verarbeiten momentan aber nur skalare Größen und vor allem sollten die Werte der Datenserie äquidistant (mit Bezug z.B. zur Zeit oder hier der Dehnung) sein.

Darstellung des TT Datensatzes

plot(data.tt[1,]$x,data.tt[1,]$y,type='l')
plot(data.tt[1,]$y,type='l')

▸

[]

✗

≡

Daher muss die Datenserie linearisiert werden.
Dazu wird ein linearisierter x-Vektor erzeugt (also mit äquidistanten Δx) und y-Werte gesucht die ein x-Wert mit kleinsten Abstand besitzen.
Weiterhin muss die Datenserie normalisiert werden. Bei Verwendung von sigmoid/logistik Aktivierungsfunktionen ist ein Bereich (0,1) ohne o/u Grenzen erforderlich.

Frage. Wie ist das Delta (delta, Verschiebung) zu wählen? Das Delta bestimmt die Recihweite bei der Prognose eines Zukunftswertes.

Linarisierung und Normalisierung des TT Datensatzes

use  plot
delta=5
delta.x=0.002
function linearize(xs,ys) {
  xe=seq(0,0.5,delta.x)
  ye=vector(length(xe))
  i=1
  j=1
  for(x in xe) {
    for(k in i:length(xs)) {
       if (xs[k]>=x) {
         # print(j)
         ye[j]=ys[k]
         j=incr(j)
         i=k
         break
       }
    }
  }
  ye
}
data.tt.y = list()
data.tt.y.d = list()
for(index in 1:nrow(data.tt)) {
  xs=data.tt[index,]$x
  ys=data.tt[index,]$y
  ye=linearize(xs,ys)/5000
  n=length(ye)
  yd=vector(n)
  yd[1:(n-delta)]=ye[delta:n]
  push(data.tt.y,ye)
  push(data.tt.y.d,yd)
}
logg(typeof(data.tt.y))
plot({y=data.tt.y[[1]],yd=data.tt.y.d[[1]]},type='l')

▸

[]

✗

≡

Randomisierung

Die Datensätze besitzen och eine Ordnung (welche auch immer, Experimentreihenfolge, Gruppen von Materialien usw.).

Daher ist eine Randomisierung der Reihenfolge der Datensätze für das Training erforderlich.
jetzt haben wir aber schon zwei Tabellen:
- data.tt.y mit originalen aber linearisierten y-Daten
- data.tt.y.d mit den um δ verschobenen Datenserien (für das Training)
Daher wird ein randomisierter Indexvektor erzeugt, der gleichermaßen auf beiden Tabellen (Listen) angewendet wird und neu (randomisiert) angeordnete Listen erzeugt.

Randomisierung des TT Datensatzes

use plot
index=seq(1,nrow(data.tt))
index=sample(index)
data.tt.y=data.tt.y[index]
data.tt.y.d=data.tt.y.d[index]
logg(typeof(data.tt.y))
plot({y=data.tt.y[[1]],yd=data.tt.y.d[[1]]},type='l')

▸

[]

✗

≡

LSTM Modell

LSTM Modell für Vorhersage von Zugversuchskurven

use ann
model.lstm = ann([1,4,4,1],architect="lstm",details={
  memoryToMemory=FALSE,
  outputToMemory=TRUE,
  outputToGates=FALSE,
  inputToOutput=TRUE,
  inputToDeep=TRUE
},activations=['relu','tanh','tanh','relu'])
print(summary(model.lstm))

▸

[]

✗

≡

Frage. Welche Punkt (welche Punkte) der Zugversuchskurve sollte vorhergesagt werden?

LSTM Training (Zugversuch)

Hier wird das Modell iterative mit allen Datenserien trainiert. Je nach Serie wird es unterschiedliche Fehler geben.

Ob sich eine Konvergenz einstellt ist unbestimmt (d.h. generalisiertes Modell vs. spezielles)
Die Trainingsschleife kann mehrfach wiederholt werden. Nach jedem Schleifendurchlauf einen Test durchführen.

Iteratives Training des LSTM Modells mit Instanzen des TT Datensatzes

use ann
for(index in 1:length(data.tt.y)) {
  result=train(model.lstm,data.tt.y[[index]],
                          data.tt.y.d[[index]],
                          epochs=10,rate=0.01)
  result$index=index
  cprint(result)
}

▸

[]

✗

≡

LSTM Test (Zugversuch)

Test des LSTM Modells mit Instanzen des TT Datensatzes

index=11
plot({y=data.tt.y[[index]],
       y.d=data.tt.y.d[[index]],
       yp=predict(model.lstm,data.tt.y[[index]])
       },type='l')

▸

[]

✗

≡

Frage. Kann der Übergang vom elastischen zum plastischen Bereich vorhergesagt werden?

Created by the NoteBook Compiler Ver. 1.27.2 (c) Dr. Stefan Bosse (Wed Jul 17 2024 23:49:42 GMT+0200 (Central European Summer Time))