Deep Learning

Grundlagen

Dr. Stefan Hackstein

 

stefan.hackstein@fhnw.ch

Deep Learning

Grundlagen

Slides

slides.com/stefanhackstein/deep-learning-grundlagen

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)

Lineare Regression

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

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 = 0 \\ c_2 = 0 \\ c_3 = 1

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

Machine Learning

Machine Learning

Deep Learning

Deep Learning

Deep Learning

  • Universeller Funktionsapproximator
     
  • Findet Basisfunktionen selbst
    mit Linearer Regression

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

Deep Learning

  • Findet Basisfunktionen selbst
    mit Linearer Regression
\hat f(x) = \sum\limits_{k=1}^n c_k \Phi_k^{L}(x)

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

Deep Learning

  • Spezialgebiet des Machine Learning
     
  • Universeller Funktionsapproximator: Neuronale Netze

Deep Learning

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

Deep Learning

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

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
    (16.09., 30.09. & 28.10. Amadeus Oertel)

  • Natural Language Processing: Übersetzungen, Chatbots
    (22.09., 29.09. & 20.10. Fabian Märki & Joel Akaret)

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
    (10.11. Yanick Schraner)

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
    (03.11. Fernando Benites)

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
    (04.11., 17.11. & 08.12. Susanne Suter)

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
    (16.09., 30.09. & 28.10. Amadeus Oertel)

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
    (16.09., 30.09. & 28.10. Amadeus Oertel)

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
    (16.09., 30.09. & 28.10. Amadeus Oertel)

  • Natural Language Processing: Übersetzungen, Chatbots
    (22.09., 29.09. & 20.10. Fabian Märki & Joel Akaret)

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
    (10.11. Yanick Schraner)

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
    (03.11. Fernando Benites)

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
    (04.11., 17.11. & 08.12. Susanne Suter)

Deep Learning

Anwendungen

  • Natural Language Processing: Übersetzungen, Chatbots
    (22.09., 29.09. & 20.10. Fabian Märki & Joel Akaret)

Deep Learning

Anwendungen

  • Natural Language Processing: Übersetzungen, Chatbots
    (22.09., 29.09. & 20.10. Fabian Märki & Joel Akaret)

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
    (16.09., 30.09. & 28.10. Amadeus Oertel)

  • Natural Language Processing: Übersetzungen, Chatbots
    (22.09., 29.09. & 20.10. Fabian Märki & Joel Akaret)

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
    (10.11. Yanick Schraner)

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
    (03.11. Fernando Benites)

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
    (04.11., 17.11. & 08.12. Susanne Suter)

Deep Learning

Anwendungen

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
    (10.11. Yanick Schraner)

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
    (16.09., 30.09. & 28.10. Amadeus Oertel)

  • Natural Language Processing: Übersetzungen, Chatbots
    (22.09., 29.09. & 20.10. Fabian Märki & Joel Akaret)

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
    (10.11. Yanick Schraner)

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
    (03.11. Fernando Benites)

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
    (04.11., 17.11. & 08.12. Susanne Suter)

Deep Learning

Anwendungen

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
    (03.11. Fernando Benites)

Deep Learning

Anwendungen

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
    (03.11. Fernando Benites)

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
    (16.09., 30.09. & 28.10. Amadeus Oertel)

  • Natural Language Processing: Übersetzungen, Chatbots
    (22.09., 29.09. & 20.10. Fabian Märki & Joel Akaret)

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
    (10.11. Yanick Schraner)

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
    (03.11. Fernando Benites)

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
    (04.11., 17.11. & 08.12. Susanne Suter)

Deep Learning

Anwendungen

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
    (04.11., 17.11. & 08.12. Susanne Suter)

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
    (16.09., 30.09. & 28.10. Amadeus Oertel)

  • Natural Language Processing: Übersetzungen, Chatbots
    (22.09., 29.09. & 20.10. Fabian Märki & Joel Akaret)

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
    (10.11. Yanick Schraner)

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
    (03.11. Fernando Benites)

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
    (04.11., 17.11. & 08.12. Susanne Suter)

Deep Learning

Good Practice

nach Karpathy: A receipe for training neural networks

Case Study: Fragestellung

  • Forschungsfragen
  • Ziele
  • Anwendungsdomäne
  • Daten

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

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

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

Deep Learning

Good Practice

Karpathy: A receipe for training neural networks

 

 

Lones: How to avoid machine learning pitfalls

Daten

Erkunden

Daten Erkunden

  • Verstehen: Inhalt, Format, Label, Metadaten

Daten Erkunden

  • Verstehen: Inhalt, Format, Label, Metadaten

     
  • Visualisieren: Verteilung, Korrelation, Ausreisser
     

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)

Die letzte Zeile erwartet 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)

Supervised

Lernen mit Zieldaten (Label /  Target)

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

Unsupervised

Lernen ohne Zieldaten

Unsupervised

Lernen ohne Zieldaten

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

Reinforcement

Interaktion mit Umgebung

Reinforcement

Interaktion mit Umgebung

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

Modell &

Training

Modell

Deep Learning Modell = Neuronales Netz

Neuronales Netz = einfache Dartstellung sehr komplizierter Rechnung

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

mehr zu Neuronalen Netzen

Layer

Layer = Level für Lineare Regression

Mehrere Knoten (Perceptronen)

Knoten = gewichtete Summe & Aktivierungsfunktion

mehr zu Neuronalen Netzen

Aktivierungsfunktion

\sigma(x) = \frac{1}{1 + e^{-x}}

Aktivierungsfunktion

\sigma(x) = \frac{1}{1 + e^{-x}}
\tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}

Aktivierungsfunktion

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

Aktivierungsfunktion

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

Wahl der Aktivierung:

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

Mehr zu Aktivierungen

Aktivierungsfunktion

Aktivierungsfunktion

Architektur entwerfen

Wenn möglich, bereits existierende Architektur / Modelle verwenden

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

Implementation

Pytorch

  • Gentle learning curve
  • More Pythonic
  • Research-oriented

Tensorflow

  • Steep learning curve
  • Multi-Language support
  • Production-oriented

Implementation

Pytorch

  • Gentle learning curve
  • More Pythonic
  • Research-oriented

Tensorflow

  • Steep learning curve
  • Multi-Language support
  • Production-oriented

Beide Frameworks sehr nützlich & weit verbreitet

 

Mathematik identisch & Aufbau sehr ähnlich 

 

Wahl meist durch Arbeitsumfeld bestimmt

Trainingsloop

  1. Daten laden (batch)
  2. Modell anwenden (forward)
  3. Loss berechnen
  4. Updates berechnen (backward)
  5. Update durchfüren

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


     
MSE = \frac{1}{N} \sum_{i=1}^{N} (y_i - \hat{y}_i)^2

Loss Funktion

  • Mean Squared Error (MSE):
    mittlerer quadratische Abweichung



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


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)]

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}
\text{Lernrate } \alpha

Update

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

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

Update

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

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

Update

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

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

Optimizer

Stochastic Gradient Descent (SGD)

\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}

Optimizer

Stochastic Gradient Descent (SGD)

\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}

Optimizer

Stochastic Gradient Descent (SGD)

\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}

Optimizer

Stochastic Gradient Descent (SGD)

\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} \\~\\

Optimizer

Stochastic Gradient Descent (SGD)

\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} \\~\\ = 2(y_i - \hat{y}_i) \cdot 1 \cdot \frac{\partial a}{\partial z} \cdot 1

Optimizer

Stochastic Gradient Descent (SGD)

\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} \\~\\ = 2(y_i - \hat{y}_i) \cdot \frac{\partial a}{\partial z}

Optimizer

Stochastic Gradient Descent (SGD)

\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} } \\~\\ = 2(y_i - \hat{y}_i) {\color{red} \frac{\partial a_1}{\partial z_1} }

Optimizer

Stochastic Gradient Descent (SGD)

\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} } \\~\\ = 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} }

Optimizer

Stochastic Gradient Descent (SGD)

\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} } \\~\\ = 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} }

Optimizer

Stochastic Gradient Descent (SGD)

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

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

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:

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

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

Overfitting

  • zu stark an Trainingsdaten angepasst
  • schlechte verallgemeinerung auf Testdaten

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 osziliert -> 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

Regularisieren

Text

Regularisieren

  • reduziert Overfitting
     
  • verbessert Generalisierung
     
  • Balance: Komplexität - Generalisierung
     
  • robustere Models

mehr zum Thema

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()

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))

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

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
    (16.09., 30.09. & 28.10. Amadeus Oertel)

  • Natural Language Processing: Übersetzungen, Chatbots
    (22.09., 29.09. & 20.10. Fabian Märki & Joel Akaret)

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
    (10.11. Yanick Schraner)

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
    (03.11. Fernando Benites)

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
    (04.11., 17.11. & 08.12. Susanne Suter)

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
    (16.09., 30.09. & 28.10. Amadeus Oertel)

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
    (16.09., 30.09. & 28.10. Amadeus Oertel)

  • Natural Language Processing: Übersetzungen, Chatbots
    (22.09., 29.09. & 20.10. Fabian Märki & Joel Akaret)

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
    (10.11. Yanick Schraner)

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
    (03.11. Fernando Benites)

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
    (04.11., 17.11. & 08.12. Susanne Suter)

Deep Learning

Anwendungen

  • Natural Language Processing: Übersetzungen, Chatbots
    (22.09., 29.09. & 20.10. Fabian Märki & Joel Akaret)

Deep Learning

Natural Language Processing

Transformer

Transformiert Sequenz zu neuer Sequenz

Deep Learning

Natural Language Processing

Transformer

  • Autovervollständigung
  • Übersetzung
  • Chatbots

Deep Learning

Natural Language Processing

Recurrent Neural Network (RNN)

Verwendet letzten Output

-> Kurzzeitgedächtnis

Deep Learning

Anwendungen

  • Computer Vision: Klassifizierung, Objekterkennung, Bildgenerierung
    (16.09., 30.09. & 28.10. Amadeus Oertel)

  • Natural Language Processing: Übersetzungen, Chatbots
    (22.09., 29.09. & 20.10. Fabian Märki & Joel Akaret)

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
    (10.11. Yanick Schraner)

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
    (03.11. Fernando Benites)

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
    (04.11., 17.11. & 08.12. Susanne Suter)

Deep Learning

Anwendungen

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
    (10.11. Yanick Schraner)

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
    (16.09., 30.09. & 28.10. Amadeus Oertel)

  • Natural Language Processing: Übersetzungen, Chatbots
    (22.09., 29.09. & 20.10. Fabian Märki & Joel Akaret)

  • Reinforcement Learning: Gaming, Robotik, Automatisierung
    (10.11. Yanick Schraner)

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
    (03.11. Fernando Benites)

  • Explainable AI: Transparenz, Vertrauen, Sicherheit
    (04.11., 17.11. & 08.12. Susanne Suter)

Deep Learning

Anwendungen

  • Zeitreihenanalyse: Markt- & Wetterprognosen, Anomalieerkennung
    (03.11. Fernando Benites)

Deep Learning

Zeitreihenanalyse

Kurzzeit-

Gedächtnis

Text

Langes

Kurzzeit-

Gedächtnis

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.