Deep Learning

Grundlagen

Dr. Stefan Hackstein

 

stefan.hackstein@fhnw.ch

Deep Learning

Abschlusstag: 12. Januar, Vormittags?

Deep Learning

Grundlagen

Machine Learning

Deep Learning

Machine Learning

Strukturen in Daten finden

Machine Learning

\hat f(x) = \sum\limits_{k=1}^n c_k \Phi_k(x)
\Phi_1 = 1 \\ \Phi_2 = x \\ \Phi_3 = x^2
c_1 \approx 0 \\ c_2 \approx 0 \\ c_3 \approx 1

Lineare Regression

Machine Learning

\hat f(x) = \sum\limits_{k=1}^n c_k \Phi_k(x)
  • Genereller Funktionsapproximator
  • braucht geeignete Basisfunktionen
  • braucht kuratierte Daten

 

Mehr zu Machine Learning

Lineare Regression

Machine Learning

Machine Learning

Deep Learning

Deep Learning

Deep Learning

  • Universeller Funktionsapproximator
     
  • Findet Basisfunktionen selbst?
\hat f(x) = \sum\limits_{k=1}^{n_L} c^{L}_k \Phi_k^{L}(x)

Deep Learning

  • Findet Basisfunktionen selbst
    mit Linearer Regression
\hat f(x) = \sum\limits_{k=1}^{n_L} c^{L}_k \Phi_k^{L}(x) \\ \Phi_k^{L}(x) = \sum\limits_{k=1}^{n_{L-1}} c^{L-1}_k \Phi_k^{L-1}(x) \\ \vdots \\ \Phi_k^{1}(x) = \sum\limits_{k=1}^N c^{1}_k x_k \\

Deep Learning

  • Findet Basisfunktionen selbst
    mit Linearer Regression
\hat f(x) = \sum\limits_{k=1}^{n_L} c^{L}_k \Phi_k^{L}(x) \\ \Phi_k^{L}(x) = \sum\limits_{k=1}^{n_{L-1}} c^{L-1}_k \Phi_k^{L-1}(x) \\ \vdots \\ \Phi_k^{1}(x) = \sum\limits_{k=1}^N c^{1}_k x_k \\

Output Layer

 

 

 

 

Hidden Layers

Input Layer

Deep Learning

  • Findet Basisfunktionen selbst
    mit Linearer Regression
\hat f(x) = \sum\limits_{k=1}^n c_k \Phi_k^{L}(x)
\Phi_k^1 = x_k
\Phi_k^{l} = \sum_k c_k^l \Phi_k^{l-1}
\Phi^l= w \cdot x + b

Weights * Inputs + Bias

Deep Learning

  • Findet Basisfunktionen selbst
    mit Linearer Regression
\hat f(x) = \sum\limits_{k=1}^n c_k \Phi_k^{L}(x)
\Phi_k^1 = x_k
\Phi_k^{l} = \sum_k c_k^l \Phi_k^{l-1}
\Phi^l= w \cdot x + b

Weights * Inputs + Bias

mehr zu Neuronalen Netzen

Deep Learning

  • Spezialgebiet des Machine Learning
     
  • Universeller Funktionsapproximator: Neuronale Netze
     
  • Komplexe Algorithmen

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
     

  • Natural Language Processing: Übersetzungen, Chatbots
     

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
     

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
     

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
     

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
     

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
     

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
     

  • Natural Language Processing: Übersetzungen, Chatbots
     

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
     

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
     

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
     

Deep Learning

Anwendungen

  • Natural Language Processing: Übersetzungen, Chatbots
     

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
     

  • Natural Language Processing: Übersetzungen, Chatbots
     

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
     

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
     

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
     

Deep Learning

Anwendungen

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
     

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
     

  • Natural Language Processing: Übersetzungen, Chatbots
     

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
     

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
     

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
     

Deep Learning

Anwendungen

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
     

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
     

  • Natural Language Processing: Übersetzungen, Chatbots
     

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
     

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
     

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
     

Deep Learning

Anwendungen

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
     

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
     

  • Natural Language Processing: Übersetzungen, Chatbots
     

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
     

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
     

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
     

Deep Learning

Good Practice

  1. Daten Erkunden

  2. Modell & Trainingsloop erstellen

  3. Evaluieren

  4. Overfitten

  5. Regularisieren

  6. Optimieren

nach Karpathy: A receipe for training neural networks

Case Study: Fragestellung

  • Forschungsfragen
  • Ziele
  • Anwendungsdomäne
  • Daten

Report

  • Diskussion
  • Konklusion

Auch hilfreich: Lones: How to avoid machine learning pitfalls

Daten Erkunden

  • Verstehen: Inhalt, Format, Label, Metadaten

     
  • Visualisieren: Verteilung, Korrelation, Ausreisser

     
  • Preprocessing: normalisieren, skalieren, enkodieren, balancieren

Mehr Data-Exploration Techniken

Daten Erkunden

Hands-On: MNIST Datensatz

 

Öffnen sie dieses Notebook und bearbeiten Sie die Aufgaben. Beantworten Sie so folgende Fragen:

  1. Welche Daten enthält der Datensatz?
  2. Welches Format haben die Daten?
  3. Welche Klassen gibt es und wie sind diese verteilt?
  4. Wie machen wir die Klassen dem Modell verständlich?
  5. Welche Skalierung der Daten ist sinnvoll?

 

Die Lösung finden Sie in diesem Notebook

Notebook auf Drive kopieren um Resultate zu speichern

Daten Erkunden

Hands-On: MNIST Datensatz

 

Welche Daten enthält der Datensatz?

data.shape -> (N_data, size_input)

Die shape eines Datensatzes zeigt die Anzahl der Elemente (N_data) sowie das format der einzelnen Elemente (size_input)

Daten Erkunden

Hands-On: MNIST Datensatz

 

Welches Format haben die Daten?

Die type(x) Funktion gibt die Klasse von x an

type(data[0]) -> class

Die built-in Funktion x.dtype gibt den Datentyp von x an

data.dtype -> data_type

Daten Erkunden

Hands-On: MNIST Datensatz

 

Welche Klassen gibt es und wie sind diese verteilt?

numpy.unique(x) liefert eine liste aller Elemente die in x vorkommen

labels = np.unique(target)

numpy.bincount(x) liefert die Anzahl von Integerwerten in x, geordnet nach Zahlenwert der Integer

counts = np.bincount(target.astype(int))

Daten Erkunden

Hands-On: MNIST Datensatz

 

Wie machen wir die Klassen dem Modell verständlich?

Um Stringlabel in für das Modell verständliche Floats zu verwandeln nutzen wir One-Hot-Encoding

# zB "3" -> [0,0,0,1,0,0,0,0,0,0]
# 
from sklearn.preprocessing import OneHotEncoder
encoder = OneHotEncoder()
labels = encoder.fit_transform(target)

Achtung: Die letzte Zeile erwartet hier target mit shape (N,1)

Daten Erkunden

Hands-On: MNIST Datensatz

 

Welche Skalierung der Daten ist sinnvoll?

In den Knoten eines Neuronalen Netzes werden viele Werte aufsummiert, was zu sehr grossen Ergebnissen führen kann.

Ausserdem haben grundsätzilch hohe Features ein stärkeres Gewicht.

Um das zu verhindern werden die Input-Daten auf [-1,1] skaliert.

Dazu benutzt man idR das Min-Max scaling

\frac{{data - \min(data)}}{{\max(data) - \min(data)}} \cdot 2 - 1
scaled_data = (data - np.min(data)) / (np.max(data) - np.min(data)) * 2 - 1

Deep Learning

Mehr zum Thema

Supervised

Lernen mit Zieldaten (Label /  Target)

  • Target fuer jeden Datensatz
  • Training durch vergleich Output = Target
  • Klassifizierung, Spracherkennung

Unsupervised

Lernen ohne Zieldaten

  • Kein Target pro Datensatz
  • Muster & Strukturen erkennen 
  • Clustering, Dimensionsreduktion

Reinforcement

Interaktion mit Umgebung

  • Lernen durch Interaktion
  • Belohnung & Bestrafung
  • Spiele, Roboter, Autonome Systeme

Deep Learning Modell

Architektur: Neuronale Netzstruktur

Neuronales Netz = einfache Dartstellung sehr komplizierter Rechnung

LinReg mit Basisfunktionen aus LinReg mit Basis aus Linreg mit Basis aus ...

Modell = Architektur mit Satz von Parametern

mehr zu Neuronalen Netzen

Layer

Layer = Level für Lineare Regression

Mehrere Knoten (Perceptronen)

Knoten = gewichtete Summe & Aktivierungsfunktion

mehr zu Neuronalen Netzen

Aktivierungsfunktion

\mathbf{z_2} = \mathbf{W_2} \mathbf{z_1} + \mathbf{b_2}
\mathbf{z_1} = \mathbf{W_1} \mathbf{x} + \mathbf{b_1}
= \mathbf{W_2} (\mathbf{W_1} \mathbf{x} + \mathbf{b_1}) + \mathbf{b_2}
= \mathbf{W_2} \mathbf{W_1} \mathbf{x} + \mathbf{W_2} \mathbf{b_1} + \mathbf{b_2}
= \mathbf{W_{ges}} \mathbf{x} + \mathbf{b_{ges}}

Wofür Aktivierung?

 

Ohne Aktivierung: N Layer = 1 Layer

 

Lineare Kombination
von Linearkombinationen
ist eine Linearkombination

 

Nicht-Lineare Aktivierung
ermöglicht komplexe Modellierung

z_{1,j} = \sum_{i=1}^{n} c_{1,ij} \cdot x_i
z_2 = \sum_{j=1}^{m} c_{2,j} \cdot z_{1,j}
= \sum_{i=1}^{n} \left( \sum_{j=1}^{m} c_{2,j} \cdot c_{1,ij} \right) \cdot x_i
= \sum_{i=1}^{n} c_{\text{ges}, i} \cdot x_i
= \sum_{j=1}^{m} c_{2,j} \cdot \left( \sum_{i=1}^{n} c_{1,ij} \cdot x_i \right)

Aktivierungsfunktion

\text{Sigmoid}\\ \sigma(x) = \frac{1}{1 + e^{-x}}
\tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}
\text{ReLU}(x) = \max(0, x)

Mehr zu Aktivierungen

Wahl der Aktivierung:

  • Output: Wertebereich Target
  • Hidden: Effizienz (?)

Aktivierungsfunktion

\text{Sigmoid}\\ \sigma(x) = \frac{1}{1 + e^{-x}} \\ \sigma'(x) = \sigma(x)(1-\sigma(x))
\tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}} \\ \tanh'(x) = 1 - \tanh^2(x)
\text{ReLU}(x) = \max(0, x) \\ \text{ReLU}'(x) = \begin{cases} 0 & \text{if } x < 0 \\ 1 & \text{if } x > 0 \end{cases}

Wahl der Aktivierung:

  • Output: Wertebereich Target
  • Hidden: Effizienz (ReLU)

Mehr zu Aktivierungen

Aktivierungsfunktion

\text{ReLU}(x) = \max(0, x) \\ \text{ReLU}'(x) = \begin{cases} 0 & \text{if } x < 0 \\ 1 & \text{if } x > 0 \end{cases}

Dying ReLU:

  • Permanent x < 0
  • ReLU & Ableitung = 0
  • Perceptron lernt nicht
  • Wird Unbrauchbar

Aktivierungsfunktion

\text{ReLU}(x) = \max(0, x) \\ \text{ReLU}'(x) = \begin{cases} 0 & \text{if } x < 0 \\ 1 & \text{if } x > 0 \end{cases}

Dying ReLU:

  • Permanent x < 0
  • ReLU & Ableitung = 0
  • Perceptron lernt nicht
  • Wird Unbrauchbar

PReLU, RReLU, ELU, SELU, GELU, Swish, Mish, ReLU6, ...

\text{Leaky ReLU}(x) = \max(\alpha x, x) \\ \text{Leaky ReLU}'(x) = \begin{cases} \alpha & \text{if } x < 0 \\ 1 & \text{if } x > 0 \end{cases}
\text{ALReLU}(x) = \begin{cases} x & \text{if } x > 0 \\ |\alpha \cdot x| & \text{if } x < 0 \end{cases} \\ \text{ALReLU}'(x) = \begin{cases} 1 & \text{if } x > 0 \\ -\alpha & \text{if } x < 0 \end{cases}

nützlich bei sehr seltener Aktivierung

Aktivierungsfunktion

Implementation

Pytorch  Tensorflow
Eigenschaften Pythonic, einfache Syntax
schnelleres Training
dynamischer Berenchnungsgraph
höhere Flexibilität		 Skalierbar
Speichereffizient
statisch oder dynamisch
Hauptanwendung Forschung
Prototyping		 Grossprojekte
Produktion
Community Forschung Industrie
Pakete TorchText, TorchVision, TorchAudio TF Extended, TF Lite, TF Serving

Beide Frameworks sehr nützlich & weit verbreitet

Mathematik identisch & Aufbau sehr ähnlich

Wahl meist durch Arbeitsumfeld bestimmt

Architektur entwerfen

  1. Aufgabe klar definieren (Klassifikation, Regression, Erkennung, ...)
  2. Ein- und Ausgabedimension festlegen  (MNIST: In: 784; Out: 10)
  3. Geeignete Art von Schichten bestimmen (Linear, Convolutional, ...)
  4. Anzahl Schichten und Neuronen pro Schicht festlegen
  5. Aktivierungsfunktionen festlegen (Hidden & Output)

Wenn möglich, bereits existierende Architektur / Modelle verwenden

Implementation

  • MNIST Classifier

Implementation

from torch import nn
import torch.nn.functional as F

class Classifier(nn.Module):
    def __init__(self):
        super().__init__()
        
        
        
        

    def forward(self, x):
        
        
        
        
        return x

model = Classifier()
output = model(data)

Pytorch (Meta)

  • MNIST Classifier

Implementation

from torch import nn
import torch.nn.functional as F

class Classifier(nn.Module):
    def __init__(self):
        super().__init__()
        
        
        
        self.fc4 = nn.Linear(784, 10)

    def forward(self, x):
        
        
        
        x = self.fc4(x)
        return x

model = Classifier()
output = model(data)

Pytorch (Meta)

  • MNIST Classifier
  • 10 Outputs

Implementation

from torch import nn
import torch.nn.functional as F

class Classifier(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 64)
        self.fc2 = nn.Linear(64, 64)
        self.fc3 = nn.Linear(64, 64)
        self.fc4 = nn.Linear(64, 10)

    def forward(self, x):
        x = self.fc1(x)
        x = self.fc2(x)
        x = self.fc3(x)
        x = self.fc4(x)
        return x

model = Classifier()
output = model(data)

Pytorch (Meta)

  • MNIST Classifier
  • 10 Outputs
  • 3 Hidden Layer

Implementation

from torch import nn
import torch.nn.functional as F

class Classifier(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 64)
        self.fc2 = nn.Linear(64, 64)
        self.fc3 = nn.Linear(64, 64)
        self.fc4 = nn.Linear(64, 10)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = F.relu(self.fc3(x))
        x = self.fc4(x)
        return x

model = Classifier()
output = model(data)

Pytorch (Meta)

  • MNIST Classifier
  • 10 Outputs
  • 3 Hidden Layer 

Implementation

from torch import nn
import torch.nn.functional as F

class Classifier(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 64)
        self.fc2 = nn.Linear(64, 64)
        self.fc3 = nn.Linear(64, 64)
        self.fc4 = nn.Linear(64, 10)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = F.relu(self.fc3(x))
        x = F.softmax(self.fc4(x), dim=1)
        return x

model = Classifier()
output = model(data)

Pytorch (Meta)

  • MNIST Classifier
  • 10 Outputs
  • 3 Hidden Layer
  • Softmax activation

Implementation

from torch import nn
import torch.nn.functional as F

class Classifier(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 64)
        self.fc2 = nn.Linear(64, 64)
        self.fc3 = nn.Linear(64, 64)
        self.fc4 = nn.Linear(64, 10)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = F.relu(self.fc3(x))
        x = F.softmax(self.fc4(x), dim=1)
        return x

model = Classifier()
output = model(data)

Pytorch (Meta)

import tensorflow as tf
from tensorflow.keras import layers

class Classifier(tf.keras.Model):
    def __init__(self):
        super(Classifier, self).__init__()
        self.fc1 = layers.Dense(64, activation='relu')
        self.fc2 = layers.Dense(64, activation='relu')
        self.fc3 = layers.Dense(64, activation='relu')
        self.fc4 = layers.Dense(10, activation='softmax')

    def call(self, x):
        x = self.fc1(x)
        x = self.fc2(x)
        x = self.fc3(x)
        x = self.fc4(x)
        return x

model = Classifier()
model.build((None, 784))
model(data)

Tensorflow (Google)

  • MNIST Classifier
  • 10 Outputs
  • 3 Hidden Layer
  • Softmax activation

Implementation

import torch.nn as nn

model = nn.Sequential(
    nn.Linear(784, 64),
    nn.ReLU(),
    nn.Linear(64, 64),
    nn.ReLU(),
    nn.Linear(64, 64),
    nn.ReLU(),
    nn.Linear(64, 10),
    nn.Softmax(dim=1)
)

output = model(data)

Pytorch (Meta)

from tensorflow.keras import models

model = models.Sequential([
    layers.Dense(64, activation='relu', input_shape=(784,)),
    layers.Dense(64, activation='relu'),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

model(data)

Tensorflow (Google)

  • MNIST Classifier
  • 10 Outputs
  • 3 Hidden Layer
  • Softmax activation

Trainingsloop

  1. Daten laden (batch)
  2. Modell anwenden (forward)
  3. Loss berechnen
  4. Updates berechnen (backward)
  5. Update durchfüren
for images, labels in trainloader:
    prediction = model(images)
    loss = criterion(prediction, labels)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
trainloader = DataLoader(trainset, batch_size=256, shuffle=True)

Trainingsloop entwerfen

  1. Aufgabe klar definieren
  2. Lossfunktion bestimmen
  3. Berechnungsschritte definieren

Loss Funktion

  • Definiert das Ziel des Trainings
  • Ziel: Loss minimieren
  • erlaubt Vergleich von Modellen
  • verschiedene Losses für verschiedene Aufgaben

Loss Funktion

  • Mean Squared Error (MSE):
    mittlerer quadratische Abweichung


     
  • Binäre Cross-Entropy (BCE):
    vergleich von Wahrscheinlichkeit einer Klasse


     
  • Cross-Entropy (CE):
    vergleich von Wahrscheinlichkeiten mehrerer Klassen
MSE = \frac{1}{N} \sum_{i=1}^{N} (y_i - \hat{y}_i)^2
BCE = -\sum_{i=1}^{N} [y_i \log(\hat{y}_i) + (1 - y_i) \log(1 - \hat{y}_i)]
CE = -\sum_{i=1}^{N} \sum_{c=1}^{C} y_{ic} \log(\hat{y}_{ic})

mehr zu

Hintergrund

und

Varianten

Implementation

  • Loss: CrossEntropy

Implementation

criterion = nn.CrossEntropyLoss()

Pytorch

  • Loss: CrossEntropy

Implementation

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.003)

Pytorch

  • Loss: CrossEntropy
  • Optimizer: Adam

Implementation

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.003)

for e in range(epochs):

Pytorch

  • Loss: CrossEntropy
  • Optimizer: Adam

Implementation

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.003)

for e in range(epochs):
    
    for images, labels in trainloader:

Pytorch

  • Loss: CrossEntropy
  • Optimizer: Adam

Implementation

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.003)

for e in range(epochs):
    
    for images, labels in trainloader:
        prediction = model(images)
        loss = criterion(prediction, labels)

Pytorch

  • Loss: CrossEntropy
  • Optimizer: Adam

Forward-Pass

Implementation

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.003)

for e in range(epochs):
    
    for images, labels in trainloader:
        prediction = model(images)
        loss = criterion(prediction, labels)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

Pytorch

  • Loss: CrossEntropy
  • Optimizer: Adam

Backward-Pass

Implementation

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.003)

for e in range(epochs):
    running_loss = 0
    for images, labels in trainloader:
        prediction = model(images)
        loss = criterion(prediction, labels)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

Pytorch

  • Loss: CrossEntropy
  • Optimizer: Adam

Implementation

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.003)

for e in range(epochs):
    running_loss = 0
    for images, labels in trainloader:
        prediction = model(images)
        loss = criterion(prediction, labels)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

Pytorch

  • Loss: CrossEntropy
  • Optimizer: Adam
model.compile(optimizer=optimizers.Adam(learning_rate=0.003),
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

history = model.fit(train_images, train_labels, epochs=1, batch_size=64)

print(f'Training loss: {history.history["loss"][0]}')

Tensorflow

Update

Ableitung der Kosten -> Richtung für Verbesserung -> Update

\theta \leftarrow \theta - \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta}
\alpha

Gradient Descent

Lernrate

Update

\theta \leftarrow \theta - \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta}
\text{Lernrate } \alpha

Ableitung der Kosten -> Richtung für Verbesserung -> Update

Gradient Descent

Update

Ableitung der Kosten -> Richtung für Verbesserung -> Update

\theta \leftarrow \theta - \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta}
\text{Lernrate } \alpha

Gradient Descent

Update

\theta \leftarrow \theta - \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta}
\text{Lernrate } \alpha

Ableitung der Kosten -> Richtung für Verbesserung -> Update

Gradient Descent

Optimizer

\theta \leftarrow \theta - \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta}
Loss = \sum\limits_i (y_i - \hat{y}_i)^2 \\ \text{Forward: }\hat{y} = f(x)
x \text{: Input Daten} \\ y \text{: Ziel Daten} \\ \hat{y} \text{: Vorhersage} \\ f \text{: Modell} \\ \theta \text{: Parameter}

Gradient Descent

Optimizer

\theta \leftarrow \theta - \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta}
Loss = \sum\limits_i (y_i - \hat{y}_i)^2 \\ \text{Forward: }\hat{y} = f(x) = a(z) = a(b + w \cdot x) \\~\\
b \text{: Bias} \\ w \text{: Gewichte} \\ a \text{: Aktivierung}

Gradient Descent

Optimizer

\theta \leftarrow \theta - \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta}
Loss = \sum\limits_i (y_i - \hat{y}_i)^2 \\ \text{Forward: }\hat{y} = f(x) = a(z) = a(b + w \cdot x) \\~\\ \text{Backward: }\frac{\partial Loss}{\partial b}

Gradient Descent

Optimizer

\theta \leftarrow \theta - \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta}
Loss = \sum\limits_i (y_i - \hat{y}_i)^2 \\ \text{Forward: }\hat{y} = f(x) = a(z) = a(b + w \cdot x) \\~\\ \text{Backward: }\frac{\partial Loss}{\partial b} = \frac{\partial Loss}{\partial \hat{y}_i} \cdot \frac{\partial \hat{y}_i}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial b} \\~\\

Gradient Descent

Optimizer

\theta \leftarrow \theta - \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta}
Loss = \sum\limits_i (y_i - \hat{y}_i)^2 \\ \text{Forward: }\hat{y} = f(x) = a(z) = a(b + w \cdot x) \\~\\ \text{Backward: }\frac{\partial Loss}{\partial b} = \frac{\partial Loss}{\partial \hat{y}_i} \cdot \frac{\partial \hat{y}_i}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial b} \\~\\ = \sum\limits_i 2(y_i - \hat{y}_i) \cdot 1 \cdot \frac{\partial a}{\partial z} \cdot 1

Gradient Descent

Optimizer

\theta \leftarrow \theta - \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta}
Loss = \sum\limits_i (y_i - \hat{y}_i)^2 \\ \text{Forward: }\hat{y} = f(x) = a(z) = a(b + w \cdot x) \\~\\ \text{Backward: }\frac{\partial Loss}{\partial b} = \frac{\partial Loss}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial b} \\~\\ = \sum\limits_i 2(y_i - \hat{y}_i) \cdot \frac{\partial a}{\partial z}

Gradient Descent

Optimizer

\theta \leftarrow \theta - \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta}
Loss = \sum\limits_i (y_i - \hat{y}_i)^2 \\ \text{Forward: }{\color{red} \hat{y}_i = f({\color{orange}x_i}) = {\color{red}a_1(z_1({\color{orange}x_i}))} = {\color{red} a_1(b_1 + w_1 \cdot {\color{orange}x_i})}} \\~\\ \text{Backward: }\frac{\partial Loss}{\partial b_1} = \frac{\partial Loss}{\partial a_1} \cdot {\color{red} \frac{\partial a_1}{\partial z_1} \cdot \frac{\partial z_1}{\partial b_1} } \\~\\ = \sum\limits_i 2(y_i - \hat{y}_i) {\color{red} \frac{\partial a_1}{\partial z_1} }

Gradient Descent

Optimizer

\theta \leftarrow \theta - \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta}
Loss = \sum\limits_i (y_i - \hat{y}_i)^2 \\ \text{Forward: }{\color{cyan} \hat{y}_i = f({\color{orange}x_i}) = {\color{cyan}a_2(z_2({\color{red}a_1(z_1({\color{orange}x_i}))}))} = {\color{cyan} a_2(b_2 + w_2 \cdot {\color{red} a_1(b_1 + w_1 \cdot {\color{orange}x_i})})}} \\~\\ \text{Backward: }\frac{\partial Loss}{\partial b_1} = \frac{\partial Loss}{\partial a_2} \cdot {\color{cyan} \frac{\partial a_2}{\partial z_2} \cdot \frac{\partial z_2}{\partial a_1} \cdot } {\color{red} \frac{\partial a_1}{\partial z_1} \cdot \frac{\partial z_1}{\partial b_1} } \\~\\ = \sum\limits_i 2(y_i - \hat{y}_i) \cdot{\color{cyan} \frac{\partial a_2}{\partial z_2} \cdot w_2 \cdot } {\color{red} \frac{\partial a_1}{\partial z_1} }

Gradient Descent

Optimizer

\theta \leftarrow \theta - \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta}
Loss = \sum\limits_i (y_i - \hat{y}_i)^2 \\ \text{Forward: }{\color{lightgreen} \hat{y}_i = f({\color{orange}x_i}) = a_3(z_3({\color{cyan}a_2(z_2({\color{red}a_1(z_1({\color{orange}x_i}))})) })) = a_3(b_3 + w_3 \cdot {\color{cyan} a_2(b_2 + w_2 \cdot {\color{red} a_1(b_1 + w_1 \cdot {\color{orange}x_i})})})} \\~\\ \text{Backward: }\frac{\partial Loss}{\partial b_1} = \frac{\partial Loss}{\partial a_3} \cdot {\color{lightgreen} \frac{\partial a_3}{\partial z_3} \cdot \frac{\partial z_3}{\partial a_2} \cdot } {\color{cyan} \frac{\partial a_2}{\partial z_2} \cdot \frac{\partial z_2}{\partial a_1} \cdot } {\color{red} \frac{\partial a_1}{\partial z_1} \cdot \frac{\partial z_1}{\partial b_1} } \\~\\ = \sum\limits_i 2(y_i - \hat{y}_i) \cdot {\color{lightgreen} \frac{\partial a_3}{\partial z_3} \cdot w_3 \cdot } {\color{cyan} \frac{\partial a_2}{\partial z_2} \cdot w_2 \cdot } {\color{red} \frac{\partial a_1}{\partial z_1} }

Gradient Descent

Optimizer

Berechnet Ableitung

für jedes Update

mit gesamten Datensatz

 

folgt exakt steilstem Abstieg

 

Bei Millionen von Daten

sehr rechenintensiv...

\theta \leftarrow \theta - \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta}
\frac{\partial \text{Loss}}{\partial \theta}

Gradient Descent

Optimizer

Gradient Descent

Berechnet Ableitung

für jedes Update

mit gesamten Datensatz

 

folgt exakt steilstem Abstieg

 

Bei Millionen von Daten

sehr rechenintensiv...

\theta \leftarrow \theta - \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta}
\frac{\partial \text{Loss}}{\partial \theta}

Stochastic Gradient Descent (SGD)

Zerlegt Datensatz in Batches

Update nach jeder Batch

 

folgt Schätzung des steilsten Abstiegs

Forschritt kann Schwanken

 

Schnelle Konvergenz
dank schneller Rechnung

Optimizer

\theta \leftarrow \theta - \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta}

Gradient Descent

Optimizer

SGD

\theta \leftarrow \theta - \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta}
v \leftarrow \beta \cdot v + \alpha \cdot \frac{\partial \text{Loss}}{\partial \theta} \\ \theta \leftarrow \theta - v

Momentum

mehr zu

Optimizern

Model & Trainingsloop 

Hands-On: MNIST Classifier

Bearbeiten Sie dieses Notebook

 

  • Erstellen Sie einen MNIST Classifier
     
  • Definieren Sie die Trainingsloop
     
  • Testen sie die Trainingsloop ueber zwei Epochen

 

Die Lösung finden Sie in diesem Notebook

Evaluieren

Wie gut und stabil ist mein Model?

  • Performance Messen
  • Test auf unbekannten Daten
  • Robust gegen Änderungen
  • Vergleich mit Mensch?

Performance Messen

  • Kosten vs Accuracy
    • Kosten: Training, nicht interpretierbar
    • Accuracy: verständliches Mass der Leistung

Performance Messen

  • Kosten vs Accuracy
    • Kosten: Training, nicht interpretierbar
    • Accuracy: verständliches Mass der Leistung
  • Klassifizierung:
    • Accuracy
    • Precision & Recall

Performance Messen

  • Kosten vs Accuracy
    • Kosten: Training, nicht interpretierbar
    • Accuracy: verständliches Mass der Leistung
  • Klassifizierung:
    • Accuracy (Binäres label & Balancierte Daten)
    • Precision & Recall (Reinheit & Vollständigkeit)
    • Confusion Matrix (Interpretation)
    • F1 Score (vereint Precision & Recall)

Mehr dazu hier und hier

Performance Messen

  • Kosten vs Accuracy
    • Kosten: Training, nicht interpretierbar
    • Accuracy: verständliches Mass der Leistung
  • Klassifizierung:
    • Accuracy (Binäres label & Balancierte Daten)
    • Precision & Recall (Reinheit & Vollständigkeit)
    • Confusion Matrix (Interpretation)
    • F1 Score (vereint Precision & Recall)
from sklearn.metrics import confusion_matrix, f1_score
conf_mat = confusion_matrix(all_labels, all_preds)
f1 = f1_score(all_labels, all_preds, average='macro')

Unbekannte Daten

  • Train-Test Split
  • Training mit Train, Evaluation mit Test
  • Verfolge bei Training:
    für train & test je loss & accuracy

Robust

  • Training an verschiedenen Punkten starten

Robust

  • Training an verschiedenen Punkten starten
  • k-fold cross-validation (mehr dazu)

Vergleich mit Mensch

ImageNet Klassifikation

Vergleich mit Mensch

ImageNet Klassifikation

Vergleich mit Mensch

ImageNet Klassifikation

Evaluieren

Hands-On: MNIST Classifier

Bearbeiten Sie dieses Notebook

 

  • Berechnen Sie die Konfusionsmatrix sowie den F1 score
    auf einem beliebigen Datensatz
     
  • Berechnen Sie diese explizit für ein untrainiertes Modell
    auf dem Testdatensatz

 

Die Lösung finden Sie in diesem Notebook

Overfitting

  • zu stark an Trainingsdaten angepasst
  • schlechte verallgemeinerung auf Testdaten
  • Model zu komplex / zu lange trainiert

Overfitting

  • zu stark an Trainingsdaten angepasst
  • schlechte verallgemeinerung auf Testdaten
  • Schlecht regularsiert / zu wenig Parameter

Overfitting

  • zu stark an Trainingsdaten angepasst
  • schlechte verallgemeinerung auf Testdaten
  • Schlecht regularsiert / zu wenig Parameter
N_{\text{Data}} < N_{\text{Params}}

Gezielt Overfitten

Ist das Modell geeignet, Muster zu erkennen?

  • overfitten auf einer batch (sanity check)
  • catch bugs fast
# Get one batch from the training_loader
images, labels = next(iter(training_loader))

# alternativ:
for images, labels in training_loader:
  break

# Train the model on the batch for 100 iterations
for _ in range(100):
    train(model, criterion, optimizer, [(images, labels)])

Gezielt Overfitten

Ist das Modell geeignet, Muster zu erkennen?

  • overfitten auf einer batch (sanity check)
  • catch bugs fast
  • Loss steigt -> hohe learning rate, +/- vertauscht
  • Loss explodiert -> hohe lr, numerisches problem
  • Loss oszilliert -> hohe lr, data / label fehlerhaft geladen
  • Loss plateau -> tiefe lr, backprob error, falscher Input in Loss

Vortrag zum Thema

Overfitten

Hands-On: MNIST Classifier

Bearbeiten Sie dieses Notebook

 

  • Wählen Sie eine zufällige Batch zum overfitten
     
  • Trainieren Sie auf dieser Batch für 100 Epochen
     
  • Evaluieren Sie das Modell an dieser Batch und den Testdaten

 

Die Lösung finden Sie in diesem Notebook

Text

mehr zum Thema

N_{\text{Data}} < N_{\text{Params}}

Tiefes NN kann jede Funktion fitten
    -> overfit leicht
    -> Generalisierung schwer
 

Regularisierung reduziert Varianz,
ohne Bias zu erhöhen

 

-> Modell lernt "einfach" & robust zu sein

Wieso Regularisieren?

Regularisieren

  • reduziert Overfitting
    (essentiell bei grossen NN)
     
  • verbessert Generalisierung
     
  • robustere Models & Training
     
  • Balance: Komplexität - Generalisierung

mehr zum Thema

N_{\text{Data}} < N_{\text{Params}}

Regularisieren

  • L1 (Lasso):
    • kleine Parameter
    • Gewichte -> 0  => Feature Auswahl
\text{Loss} + \beta \sum_{i=1}^{n} |\theta_i|
l1_regularization_loss = torch.norm(model.parameters(), 1)

Regularisieren

  • L1 (Lasso):
    • kleine Parameter
    • Gewichte -> 0  => Feature Auswahl

  • L2 (Ridge):
    • kleine, ausgeglichene Parameter
    • meistgebrauchte regularisation
\text{Loss} + \beta \sum_{i=1}^{n} |\theta_i|
\text{Loss} + \beta \sum_{i=1}^{n} \theta_i^2
l1_regularization_loss = torch.norm(model.parameters(), 1)
optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=beta)

Regularisieren

  • L1 (Lasso):
    • kleine Parameter
    • Gewichte -> 0  => Feature Auswahl
       
  • L2 (Ridge):
    • kleine, ausgeglichene Parameter
    • meistgebrauchte regularisation
       
  • Dropout: setzt zufällig Neuronen auf 0
    • Modell redundant & robust
\text{Loss} + \beta \sum_{i=1}^{n} |\theta_i|
\text{Loss} + \beta \sum_{i=1}^{n} \theta_i^2
l1_regularization_loss = torch.norm(model.parameters(), 1)
optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=beta)

nn.Dropout(0.2)  # 0.2 of neurons set to 0

Regularisieren

  • L1 (Lasso):
    • kleine Parameter
    • Gewichte -> 0  => Feature Auswahl
       
  • L2 (Ridge):
    • kleine, ausgeglichene Parameter
    • meistgebrauchte regularisation
       
  • Dropout: setzt zufällig Neuronen auf 0
    • Modell redundant & robust
       
  • Batch Normalization: Normalisiert Layer Input
    • Reduziert Abhängikeit von vorigen Layern
\text{Loss} + \beta \sum_{i=1}^{n} |\theta_i|
\text{Loss} + \beta \sum_{i=1}^{n} \theta_i^2
l1_regularization_loss = torch.norm(model.parameters(), 1)
optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=beta)

nn.Dropout(0.2)  # 0.2 of neurons set to 0
nn.BatchNorm1d()

PyTorch

Regularisieren

  • L1 (Lasso):
    • kleine Parameter
    • Gewichte -> 0  => Feature Auswahl
       
  • L2 (Ridge):
    • kleine, ausgeglichene Parameter
    • meistgebrauchte regularisation
       
  • Dropout: setzt zufällig Neuronen auf 0
    • Modell redundant & robust
       
  • Batch Normalization: Normalisiert Layer Input
    • Reduziert Abhängikeit von vorigen Layern
\text{Loss} + \beta \sum_{i=1}^{n} |\theta_i|
\text{Loss} + \beta \sum_{i=1}^{n} \theta_i^2
Dense(N, kernel_regularizer=keras.regularizers.l2(beta), bias_regularizer=keras.regularizers.l2(beta))

tf.keras.layers.Dropout(0.2)  # 0.2 of neurons set to 0
tf.keras.layers.BatchNormalization(),
Dense(N, kernel_regularizer=keras.regularizers.l1(beta), bias_regularizer=keras.regularizers.l1(beta))

TensorFlow

Data Augmentation

  • Mehr Daten -> grössere Modelle -> komplexere Aufgaben

Data Augmentation

  • Mehr Daten -> grössere Modelle -> komplexere Aufgaben
  • Mehr Daten durch Datenbearbeitung

Data Augmentation

  • Mehr Daten -> grössere Modelle -> komplexere Aufgaben
  • Mehr Daten durch Datenbearbeitung

Data Augmentation

  • Mehr Daten -> grössere Modelle -> komplexere Aufgaben
  • Mehr Daten durch Datenbearbeitung

Data Augmentation

  • Mehr Daten -> grössere Modelle -> komplexere Aufgaben
  • Mehr Daten durch Datenbearbeitung
  • Verbessert Generalisierung
  • Reduziert Overfitting

Mehr zu Image Augmentation

Regularisieren

Hands-On: MNIST Classifier

Bearbeiten Sie dieses Notebook

 

  • Modifizieren Sie den MNIST Classifier
    mit zwei Regularisierungen: Dropout & L2
     
  • Vergleichen Sie die Performance
    mit und ohne Regularisierung

 

Die Lösung finden Sie in diesem Notebook

Deep Learning

Möglichkeiten & Grenzen

Deep Learning

Möglichkeiten

Deep Learning

Möglichkeiten

  1. Automatisierung: Selbstfahrende Autos, Produktionsroboter, ...

Deep Learning

Möglichkeiten

  1. Automatisierung: Selbstfahrende Autos, Produktionsroboter, ...
  2. Datenanalyse: Vorhersage von Kundenverhalten, Betrugserkennung, ...

Deep Learning

Möglichkeiten

  1. Automatisierung: Selbstfahrende Autos, Produktionsroboter, ...
  2. Datenanalyse: Vorhersage von Kundenverhalten, Betrugserkennung, ...
  3. Entscheidungssysteme: Kreditvergabe, Diagnosesysteme, ...

Deep Learning

Möglichkeiten

  1. Automatisierung: Selbstfahrende Autos, Produktionsroboter, ...
  2. Datenanalyse: Vorhersage von Kundenverhalten, Betrugserkennung, ...
  3. Entscheidungssysteme: Kreditvergabe, Diagnosesysteme, ...
  4. Individualisierung: Personalisierte Werbung, individueller Support, ...

Deep Learning

Möglichkeiten

  1. Automatisierung: Selbstfahrende Autos, Produktionsroboter, ...
  2. Datenanalyse: Vorhersage von Kundenverhalten, Betrugserkennung, ...
  3. Entscheidungssysteme: Kreditvergabe, Diagnosesysteme, ...
  4. Individualisierung: Personalisierte Werbung, individueller Support, ...
  5. Optimierung: Logistik und Lieferkettenmanagement, Energieverbrauchsreduktion, ...

Deep Learning

Möglichkeiten

  1. Automatisierung: Selbstfahrende Autos, Produktionsroboter, ...
  2. Datenanalyse: Vorhersage von Kundenverhalten, Betrugserkennung, ...
  3. Entscheidungssysteme: Kreditvergabe, Diagnosesysteme, ...
  4. Individualisierung: Personalisierte Werbung, individueller Support, ...
  5. Optimierung: Logistik und Lieferkettenmanagement, Energieverbrauchsreduktion, ...
  6. Beschleunigung: Automatisierte Dokumentenprüfung, beschleunigte Datenverarbeitung, ...

Deep Learning

Gefahren

Deep Learning

Gefahren

  1. Datenschutz: Risiken bei Sammlung und Verwendung von Daten.

Deep Learning

Gefahren

  1. Datenschutz: Risiken bei Sammlung und Verwendung von Daten.
  2. Fehleranfälligkeit: Ungenauigkeiten oder Fehler in Vorhersagen, Halluzination, ...

Deep Learning

Gefahren

  1. Datenschutz: Risiken bei Sammlung und Verwendung von Daten.
  2. Fehleranfälligkeit: Ungenauigkeiten oder Fehler in Vorhersagen, Halluzination, ...
  3. Arbeitsmarktveränderungen: Risiken durch Automatisierung für Berufe und Branchen.

Deep Learning

Gefahren

  1. Datenschutz: Risiken bei Sammlung und Verwendung von Daten.
  2. Fehleranfälligkeit: Ungenauigkeiten oder Fehler in Vorhersagen, Halluzination, ...
  3. Arbeitsmarktveränderungen: Risiken durch Automatisierung für Berufe und Branchen.
  4. Transparenz: Entscheidungsprozessen schwer nachvollziehbar.

Deep Learning

Gefahren

  1. Datenschutz: Risiken bei Sammlung und Verwendung von Daten.
  2. Fehleranfälligkeit: Ungenauigkeiten oder Fehler in Vorhersagen, Halluzination, ...
  3. Arbeitsmarktveränderungen: Risiken durch Automatisierung für Berufe und Branchen.
  4. Transparenz: Entscheidungsprozessen schwer nachvollziehbar.
  5. Desinformation, Manipulation: Missbrauch, Deepfakes, ...

Deep Learning

Gefahren

  1. Datenschutz: Risiken bei Sammlung und Verwendung von Daten.
  2. Fehleranfälligkeit: Ungenauigkeiten oder Fehler in Vorhersagen, Halluzination, ...
  3. Arbeitsmarktveränderungen: Risiken durch Automatisierung für Berufe und Branchen.
  4. Transparenz: Entscheidungsprozessen schwer nachvollziehbar.
  5. Desinformation, Manipulation: Missbrauch, Deepfakes, ...
  6. Verstärkung von Ungleichheiten: durch Voreingenommenheiten in Daten.

Deep Learning

Grenzen

  1. Datenabhängigkeit: Benötigt große Datenmengen.

Deep Learning

Grenzen

  1. Datenabhängigkeit: Benötigt große Datenmengen.

Curse of Dimensionality

 

Abstände zwischen den Datenpunkten steigen exponentiell mit Dimension

 

 

Benötigte Anzahl Daten steigt Exponentiell mit Anzahl extrahierter Informationen

Deep Learning

Grenzen

  1. Datenabhängigkeit: Benötigt große Datenmengen.
  2. Rechenintensität: Erfordert erhebliche Rechenleistung und Ressourcen.

Deep Learning

Grenzen

  1. Datenabhängigkeit: Benötigt große Datenmengen.
  2. Rechenintensität: Erfordert erhebliche Rechenleistung und Ressourcen.
  3. Überanpassung: Risiko der zu spezifischen Anpassung an Trainingsdaten.

Deep Learning

Grenzen

  1. Datenabhängigkeit: Benötigt große Datenmengen.
  2. Rechenintensität: Erfordert erhebliche Rechenleistung und Ressourcen.
  3. Überanpassung: Risiko der zu spezifischen Anpassung an Trainingsdaten.
  4. Mangelnde Erklärbarkeit: Entscheidungsprozesse sind oft nicht nachvollziehbar.

Deep Learning

Grenzen

  1. Datenabhängigkeit: Benötigt große Datenmengen.
  2. Rechenintensität: Erfordert erhebliche Rechenleistung und Ressourcen.
  3. Überanpassung: Risiko der zu spezifischen Anpassung an Trainingsdaten.
  4. Mangelnde Erklärbarkeit: Entscheidungsprozesse sind oft nicht nachvollziehbar.
  5. Bias-Verstärkung: Potenzielle Verstärkung von in Daten vorhandenen Vorurteilen.

Deep Learning

Grenzen

  1. Datenabhängigkeit: Benötigt große Datenmengen.
  2. Rechenintensität: Erfordert erhebliche Rechenleistung und Ressourcen.
  3. Überanpassung: Risiko der zu spezifischen Anpassung an Trainingsdaten.
  4. Mangelnde Erklärbarkeit: Entscheidungsprozesse sind oft nicht nachvollziehbar.
  5. Bias-Verstärkung: Potenzielle Verstärkung von in Daten vorhandenen Vorurteilen.
  6. Generalisierungsproblem: Schwierigkeiten bei neuartigen Daten.

Optimieren

Optimieren

Optimieren

Modell auf unbekannten Daten optimieren

aber

Testset erst ganz zum Schluss verwenden

Train-Test-Valid Split

Modell auf unbekannten Daten optimieren

aber

Testset erst ganz zum Schluss verwenden

Weiteres Datenset absplitten

Train-Test-Valid Split

Train-Test-Valid Split

  1. verschiedene Settings wählen (Hyperparameter / Architektur)
  2. für wenige Epochen trainieren
  3. Leistung auf Validationsdaten vergleichen
  4. Setting mit bester Leistung voll trainieren
  5. Trainiertes Modell auf Testset Evaluieren

Train-Test-Valid Split

  1. verschiedene Settings wählen (Hyperparameter / Architektur)
  2. für wenige Epochen trainieren
  3. Leistung auf Validationsdaten vergleichen
  4. Setting mit bester Leistung voll trainieren
  5. Trainiertes Modell auf Testset Evaluieren
from torch.utils.data import random_split
train_ratio, valid_ratio = 0.8, 0.2

# Gesamteanzahl der Trainingsdaten
N_training = len(training_data)

# Berechne die Anzahl der Beispiele für jeden Split
train_size = int(train_ratio * N_training)
valid_size = N_training - train_size

# Teile den Trainingsdatensatz in Train und Valid auf
train_data, valid_data = random_split(training_data, 
                                      [train_size, valid_size])

Train-Test-Valid Split

  1. verschiedene Settings wählen (Hyperparameter / Architektur)
  2. für wenige Epochen trainieren
  3. Leistung auf Validationsdaten vergleichen
  4. Setting mit bester Leistung voll trainieren
  5. Trainiertes Modell auf Testset Evaluieren
from torch.utils.data import random_split
train_ratio, valid_ratio = 0.8, 0.2

# Gesamteanzahl der Trainingsdaten
N_training = len(training_data)

# Berechne die Anzahl der Beispiele für jeden Split
train_size = int(train_ratio * N_training)
valid_size = N_training - train_size

# Teile den Trainingsdatensatz in Train und Valid auf
train_data, valid_data = random_split(training_data, 
                                      [train_size, valid_size])

import tensorflow as tf
from sklearn.model_selection import train_test_split
valid_ratio = 0.2

input_data = your_input_data
labels = your_labels

input_train, input_valid, labels_train, labels_valid = 
	train_test_split(input_data, labels, test_size=valid_ratio, random_state=42)

# Create TensorFlow Datasets
train_dataset = tf.data.Dataset.from_tensor_slices((input_train, labels_train))
valid_dataset = tf.data.Dataset.from_tensor_slices((input_valid, labels_valid))

Hyperparameter

Hyperparameter

class MLP_var(nn.Module):
    def __init__(self, N_layer: int):
        super(MLP_var, self).__init__()
        layers = []
        layers.append(nn.Linear(28*28, 64))
        layers.append(nn.ReLU())
        for _ in range(N_layer-1):
            layers.append(nn.Linear(64, 64))
            layers.append(nn.ReLU())
        layers.append(nn.Linear(64, 10))
        self.model = nn.Sequential(*layers)

    def forward(self, x):
        x = x.view(x.size(0), -1)
        x = self.model(x)
        return x

Hyperparameter Search

Hyperparameter Search

Try different Values, pick best score

Hyperparameter Search

Try different Values, pick best score

Hyperparameter Search

Gridsearch

for (N_layer, lr) in product(N_layer_values, learning_rate_values):
    model = MLP_var(N_layer)
    model.to(device)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=lr)

    losses_train, losses_valid, f1_scores_train, f1_scores_valid = full_training(
      model, criterion, optimizer, training_loader, valid_loader, epochs=epochs
    )

weitere Tuning Methoden

Einfluss auf Stabilität

N_{\text{Params}}
N_{\text{Data}}

Regularisierung

Hyperparameter

Tuning

Optimizer

Aufwand

N_{\text{Params}}

Hyperparameter

Tuning

Optimizer

N_{\text{Data}}

Regularisierung

Optimieren

Hands-On: MNIST Classifier

Bearbeiten Sie dieses Notebook

 

  • Erstellen Sie einen MNIST Classifier
    mit variabler Anzahl hidden Layer
     
  • Erstellen Sie einen Validationsdatensatz
     
  • Führen sie ein Hyperparametertuning durch

 

Die Lösung finden Sie in diesem Notebook

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
     

  • Natural Language Processing: Übersetzungen, Chatbots
     

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
     

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
     

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
     

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
     

Deep Learning

Computer Vision

Convolutional Neural Network (CNN)

Findet Strukturen

Deep Learning

Computer Vision

Convolutional Neural Network (CNN)

Klassifiziert durch Strukturen

Deep Learning

Generative Modelle

Erstellen neue Daten wie Trainingsdaten

aus Zufalls-zahlen

Varational Autoencoder

Generative Adversarial Network

Deep Learning

Varational Autoencoder

  • Entfernt schrittweise Rauschen (Noise)
    um darunter liegendes Bild zu enthüllen
     
  • kann aus reinem Rauschen neue Bilder generieren

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
     

  • Natural Language Processing: Übersetzungen, Chatbots
     

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
     

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
     

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
     

Deep Learning

Anwendungen

  • Natural Language Processing: Übersetzungen, Chatbots
     

Deep Learning

Natural Language Processing

Sprachverarbeitung Wort für Wort

 

 

 

 

Wie in Kontext setzen?

RNN

Deep Learning

Natural Language Processing

Recurrent Neural Network (RNN)

Liest Satz Wort für Wort

 

 

Selbe Weights für jedes Wort

Deep Learning

Natural Language Processing

Liest Satz Wort für Wort

 

keine Parallelisierung

Deep Learning

Natural Language Processing

Transformer

Transformiert Sequenz zu neuer Sequenz

Deep Learning

Natural Language Processing

Attention layer lernt Kontext

als Stärke der Beziehung von Wörtern

Transformer

Deep Learning

Natural Language Processing

Transformer

Stacks von Encodern / Decodern

Erlaubt Parallelisierung

Deep Learning

Natural Language Processing

Transformer

  • Autovervollständigung
  • Übersetzung
  • Chatbots

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
     

  • Natural Language Processing: Übersetzungen, Chatbots
     

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
     

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
     

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
     

Deep Learning

Anwendungen

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
     

Deep Learning

Reinforcement Learning

Findet versprechendste Aktion in beliebigem Zustand

Deep Learning

Reinforcement Learning

Hin und wieder neues ausprobieren

-> auf Veränderung reagieren

Deep Learning

Reinforcement Learning

Hin und wieder neues ausprobieren

-> auf Veränderung reagieren

Es ist gut Fehler zu machen!

Deep Learning

Reinforcement Learning

Früher: Tabelle

 

 

 

 

Heute:

Neuronales Netz

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
     

  • Natural Language Processing: Übersetzungen, Chatbots
     

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
     

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
     

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
     

Deep Learning

Anwendungen

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
     

Deep Learning

Zeitreihenanalyse

Kurzzeit-

Gedächtnis

Text

Langes

Kurzzeit-

Gedächtnis

Deep Learning

Layer

Fully Connected (Dense)
Alle Neuronen verbunden
Lineare Approximation
Merkmale -> Klassifizierung
Viele lernbare Parameter (In x Out)
Hoher Rechenaufwand

Deep Learning

Layer

Fully Connected (Dense) Pooling (Pool)
Alle Neuronen verbunden Filtert informationen
Lineare Approximation Grössenreduktion
Merkmale -> Klassifizierung Robustere Modelle
Viele lernbare Parameter (In x Out) Keine Lernparameter
Hoher Rechenaufwand Geringer Rechenaufwand

Deep Learning

Layer

Fully Connected (Dense) Pooling (Pool) Convolutional (Conv)
Alle Neuronen verbunden Filtert informationen Gelernter Filter gleiteit über Daten
Lineare Approximation Grössenreduktion Extrahiert lokale Merkmale
Merkmale -> Klassifizierung Robustere Modelle Mustererkennung
Viele lernbare Parameter (In x Out) Keine Lernparameter wenige lernbare Parameter
Hoher Rechenaufwand Geringer Rechenaufwand Geringer Rechenaufwand

Deep Learning

Layer - Typische Anordnung

Convolutional (Conv) Pooling (Pool) Fully Connected (Dense)
Extrahiert lokale Merkmale Filtert informationen Merkmale -> Klassifizierung
wenige lernbare Parameter Robustere Modelle

Effizienteres Modell        Translationsinvariant      Bessere Generalisierung

Layer

Hands-On: TensorFlow CIFAR-10

Starten Sie mit diesem Notebook

 

  • Klasifizieren Sie den CIFAR-100
     
  • Vergleichen Sie verschiedene Regularisationsmethoden an CNN
     
  • Führen Sie ein Hyperparametertuning durch

 

Die Lösung finden Sie in diesem Notebook

Deep Learning Geschichte

Deep Learning Geschichte

Single Layer Perceptron

Deep Learning Geschichte

Deep Learning Geschichte

Multilayer Perceptron

Deep Learning Geschichte

Deep Learning Geschichte

Recurrent Neural Network (RNN)

Deep Learning Geschichte

Deep Learning Geschichte

Convolutional Neural Network (CNN)

Deep Learning Geschichte

Deep Learning Geschichte

Support Vector Machines

Deep Learning Geschichte

Deep Learning Geschichte

Autoencoder

Deep Learning Geschichte

Deep Learning Geschichte

AlexNet

Deep Learning Geschichte

Deep Learning Geschichte

GoogleNet

Deep Learning Geschichte

Deep Learning Geschichte

Generative Adversarial Network (GAN)

Deep Learning Geschichte

Deep Learning Geschichte

ResNet-18

Deep Learning Geschichte

Nochmal von Vorne...

Hands-On: Cifar-100 Classification

Starten Sie mit diesem Notebook

 

  • Erstellen, trainieren und evaluieren Sie einen Classifier für den Cifar-100 Datensatz

Aufs wichtige beschränken

Hands-On: Audio Noise Reduction

Starten Sie mit diesem Notebook

 

  • Optimieren Sie die Audio Entrauschung so, dass der Output weniger Rauschen zeigt als der Input, die Sprache aber trotzdem zu hören ist.

Squeeze the Juice ...

Hands-On: Pytorch MNIST Anomaly Detection

Betrachten Sie dieses Notebook

 

  • Versuchen Sie, die Performance eines der Outputs zu verbessern
    • Classifier
    • Generator (Variational Autoencoder)
    • Anomaly Detection
       
  • Vergleichen Sie die Ergebnisse der verschiedenen Anomaly Detection methoden:
    • Isolation Forest
    • Mahalanobis Distanz
    • VAE reconstruction error

Deep Learning

  • Universeller Funktionsapproximator

Deep Learning

  • Universeller Funktionsapproximator

Deep Learning

  • Universeller Funktionsapproximator
  • Mehr Daten, grössere Modelle
N_{\text{Data}} < N_{\text{Params}}

Deep Learning

  • Universeller Funktionsapproximator
  • Mehr Daten, grössere Modelle
  • Good Practice

Deep Learning

  • Universeller Funktionsapproximator
  • Mehr Daten, grössere Modelle
  • Good Practice
  • Verstehen Sie ihr Modell!

High Performance Computing

Slurm: Umgang mit HPC Rechenclustern

 

Unterlagen auf Teams:

General >  Class Materials > 20230710 - HowToSlurm.pdf

Ihre Meinung ist uns wichtig!

Bitte nehmen Sie sich einen Moment Zeit, um uns zu bewerten.

CAS - Deep Learning Grundlagen

By Stefan Hackstein

CAS - Deep Learning Grundlagen

  • 449

More from Stefan Hackstein