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

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

Daten Erkunden
Modell & Trainingsloop erstellen
Evaluieren
Overfitten
Regularisieren
Optimieren

nach Karpathy: A receipe for training neural networks

Case Study: Fragestellung

Forschungsfragen
Ziele
Anwendungsdomäne
Daten

Deep Learning

Good Practice

Daten Erkunden
Modell & Trainingsloop erstellen
Evaluieren
Overfitten
Regularisieren
Optimieren

nach Karpathy: A receipe for training neural networks

Case Study: Fragestellung

Forschungsfragen
Ziele
Anwendungsdomäne
Daten

Report

Diskussion
Konklusion

Deep Learning

Good Practice

Daten Erkunden
Modell & Trainingsloop erstellen
Evaluieren
Overfitten
Regularisieren
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:

Welche Daten enthält der Datensatz?
Welches Format haben die Daten?
Welche Klassen gibt es und wie sind diese verteilt?
Wie machen wir die Klassen dem Modell verständlich?
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

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

Architektur entwerfen

Wenn möglich, bereits existierende Architektur / Modelle verwenden

Architektur entwerfen

Aufgabe klar definieren (Klassifikation, Regression, Erkennung, ...)
Ein- und Ausgabedimension festlegen (MNIST: In: 784; Out: 10)
Geeignete Art von Schichten bestimmen (Linear, Convolutional, ...)
Anzahl Schichten und Neuronen pro Schicht festlegen
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

Daten laden (batch)
Modell anwenden (forward)
Loss berechnen
Updates berechnen (backward)
Update durchfüren

Trainingsloop

Daten laden (batch)
Modell anwenden (forward)
Loss berechnen
Updates berechnen (backward)
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

Aufgabe klar definieren
Lossfunktion bestimmen
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