TensorFlow 2.0 alpha ist erschienen. Das Framework hat einen enormen Einfluss auf die Deep‑Learning‑Community. Praktiker, Forschende und Entwickler lieben es und haben es so stark übernommen wie nie zuvor. Es ist einer der Hauptgründe für den rasanten Aufschwung all der coolen Deep‑Learning‑Anwendungen, die wir heute sehen. Gleichzeitig hat TensorFlow 1.xseine Schattenseiten (wie viele andere Frameworks auch). Wie Martin Wicke (Software Engineer im TensorFlow‑Team) auf dem TF Dev Summit ’19 sagte:
Wir haben seit 1.0 eine Menge gelernt.
Aus all den Learnings aus der großen Nutzerbasis und den GitHub‑Issues hat das TensorFlow‑Team die TensorFlow 2.0 alpha veröffentlicht – mit vielen wichtigen Änderungen für mehr Performance, bessere Developer Experience und mehr. Du kannst damit schneller Prototypen bauen und profitierst von zahlreichen modernen Deep‑Learning‑Best‑Practices. In diesem Artikel lernst du einige dieser Änderungen anhand kompakter Implementierungen kennen.
Hinweis: Die hier besprochenen Updates sind aus Sicht des Autors die wichtigsten. Du solltest bereits Erfahrung mit TensorFlow und Keras mitbringen, um dem Artikel gut folgen zu können. Folgende Ressourcen sind hilfreich, wenn du dein Wissen zu TensorFlow und Keras auffrischen möchtest:
Einige der Updates enthalten Codebeispiele. Dafür brauchst du einen Datensatz. In diesem Artikel verwenden wir den Adult‑Datensatz aus dem UCI‑Archiv.
import pandas as pd
columns =["Age","WorkClass","fnlwgt","Education","EducationNum","MaritalStatus","Occupation","Relationship","Race","Gender","CapitalGain","CapitalLoss","HoursPerWeek","NativeCountry","Income"]
data = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data',
header=None,
names=columns)
data.head()Bereitgestellt von
Age
WorkClass
fnlwgt
Education
EducationNum
MaritalStatus
Occupation
Relationship
Race
Gender
CapitalGain
CapitalLoss
HoursPerWeek
NativeCountry
Income
0
39
State-gov
77516
Bachelors
13
Never-married
Adm-clerical
Not-in-family
White
Male
2174
0
40
United-States
<=50K
1
50
Self-emp-not-inc
83311
Bachelors
13
Married-civ-spouse
Exec-managerial
Husband
White
Male
0
0
13
United-States
<=50K
2
38
Private
215646
HS-grad
9
Divorced
Handlers-cleaners
Not-in-family
White
Male
0
0
40
United-States
<=50K
3
53
Private
234721
11th
7
Married-civ-spouse
Handlers-cleaners
Husband
Black
Male
0
0
40
United-States
<=50K
4
28
Private
338409
Bachelors
13
Married-civ-spouse
Prof-specialty
Wife
Black
Female
0
0
40
Cuba
<=50K
Der Datensatz stellt eine binäre Klassifikationsaufgabe dar: Aus persönlichen Merkmalen soll vorhergesagt werden, ob eine Person mehr als 50.000 $ pro Jahr verdient oder nicht.
Lass uns etwas Basis‑Preprocessing machen und dann im Verhältnis 80:20 splitten:
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
import numpy as np
# Label Encode
le = LabelEncoder()
data = data.apply(le.fit_transform)# Segregate data features & convert into NumPy arrays
X = data.iloc[:,0:-1].values
y = data['Income'].values
# Split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=7)Bereitgestellt von
Jetzt solltest du eine lauffähige Umgebung mit installiertem TensorFlow 2.0 und den Datensatz im Workspace haben. Weiter geht’s mit den Updates.
1. Eager Execution standardmäßig aktiviert
In TensorFlow 2.0 musst du keine Session mehr erstellen und den Rechen‑Graph darin ausführen. Die Eager Execution ist in 2.0 standardmäßig aktiv, sodass du Modelle bauen und sofort ausführen kannst. Du kannst Eager Execution auch deaktivieren:
tf.compat.v1.disable_eager_execution() (vorausgesetzt, tensorflow ist als tf importiert.)
Hier ein kleiner Code‑Vergleich, der den Unterschied zeigt:
2. tf.function und AutoGraph
Eager Execution ermöglicht imperatives Programmieren. Bei verteiltem Training, umfassender Optimierung und in Produktionsumgebungen hat die Graph‑Ausführung im Stil von TensorFlow 1.x aber Vorteile. In TensorFlow 2.0 bleibt die Graph‑Ausführung erhalten – flexibler umgesetzt über tf.function und AutoGraph.
tf.function erlaubt dir, TensorFlow‑Graphs mit Python‑ähnlicher Syntax über AutoGraph zu definieren. AutoGraph unterstützt vieles aus Python wie if‑Statements, for‑ und while‑Schleifen, Iteratoren usw., mit gewissen Einschränkungen. Eine vollständige Liste der aktuell unterstützten Konstrukte findest du in der Doku. Unten siehst du, wie einfach sich ein TensorFlow‑Graph per Decorator definieren lässt.
import tensorflow as tf
# Define the forward pass@tf.functiondefsingle_layer(x, y):return tf.nn.relu(tf.matmul(x, y))# Generate random data drawn from a uniform distribution
x = tf.random.uniform((2,3))
y = tf.random.uniform((3,5))
single_layer(x, y)Bereitgestellt von
<tf.Tensor: id=73, shape=(2,5), dtype=float32, numpy=array([[0.5779363,0.11255255,0.26296678,0.12809312,0.23484911],[0.5932371,0.1793559,0.2845083,0.23249313,0.21367362]],
dtype=float32)>Bereitgestellt von
Beachte, dass du keine Sessions oder Placeholders brauchst, um single_layer() auszuführen. Das ist eine der praktischen Stärken von tf.function. Unter der Haube optimiert TensorFlow den Code, damit er schneller läuft.
3. tf.variable_scope wird nicht mehr benötigt
In TensorFlow 1.x musstest du für wiederverwendbare tf.layers mit Variablen einen tf.variable‑Block nutzen. In TensorFlow 2.0 ist das dank keras als zentrale High‑Level‑API nicht mehr nötig. Alle mit tf.layers erstellten Layer kannst du direkt in einer tf.keras.Sequential‑Defintion bündeln. Das macht den Code lesbarer, und du behältst Variablen und Losses im Blick.
Hier ein Beispiel:
# Define the model
model = tf.keras.Sequential([
tf.keras.layers.Dropout(rate=0.2, input_shape=X_train.shape[1:]),
tf.keras.layers.Dense(units=64, activation='relu'),
tf.keras.layers.Dropout(rate=0.2),
tf.keras.layers.Dense(units=64, activation='relu'),
tf.keras.layers.Dropout(rate=0.2),
tf.keras.layers.Dense(units=1, activation='sigmoid')])# Get the output probabilities
out_probs = model(X_train.astype(np.float32), training=True)print(out_probs)Bereitgestellt von
tf.Tensor([[1.][0.12573627][1.]...[1.][1.][1.]], shape=(26048,1), dtype=float32)Bereitgestellt von
Im Beispiel leitest du die Trainingsdaten einmal durchs model, um die rohen Ausgabewahrscheinlichkeiten zu erhalten. Das ist nur der Vorwärtsdurchlauf. Du kannst das Modell natürlich auch trainieren:
model.compile(loss='binary_crossentropy', optimizer='adam')
model.fit(X_train, y_train,
validation_data=(X_test, y_test),
epochs=5, batch_size=64)Bereitgestellt von
In der Forschung wie auch in der Praxis brauchst du oft eigene Layer für spezielle Anwendungsfälle. TensorFlow 2.0 macht das Schreiben und Einbinden individueller Layer extrem einfach. Du kannst auch den Forward Pass deines Modells frei anpassen.
Am leichtesten erstellst du einen Custom‑Layer, indem du die Layer‑Klasse aus tf.keras.layers erweiterst und entsprechend definierst. Du legst einen eigenen Layer an und spezifizierst seine Vorwärtsberechnung. Die Ausgabe von help(tf.keras.layers.Layer) zeigt dir, was du dafür angeben musst:
Auf Basis dieses Hinweises wirst du:
Den Konstruktor mit der Zahl der Ausgabeeinheiten definieren
In build() die Gewichte für deinen Layer hinzufügen
Im call() den Forward Pass über Matrixmultiplikation und relu() definieren
classMyDenseLayer(tf.keras.layers.Layer):# Define the constructordef__init__(self, num_outputs):super(MyDenseLayer, self).__init__()
self.num_outputs = num_outputs
# Define the build function to add the weightsdefbuild(self, input_shape):
self.kernel = self.add_variable("kernel",
shape=[input_shape[-1],
self.num_outputs])# Define the forward passdefcall(self,input):
matmul = tf.matmul(input, self.kernel)return tf.nn.relu(matmul)# Initialize the layer with 10 output units
layer = MyDenseLayer(10)# Supply the input shape
layer(tf.random.uniform((10,3)))# Display the trainable parameters of the layerprint(layer.trainable_variables)Bereitgestellt von
[<tf.Variable 'my_dense_layer_7/kernel:0' shape=(3,10) dtype=float32, numpy=array([[0.43613756,0.21344548,0.37803996,0.65583944,0.11884308,0.13909656,0.30802298,0.5313586,0.04967308,0.32889426],[0.1680265,-0.59944266,-0.4014195,0.14887196,0.07071263,0.37862527,-0.5822403,-0.5963166,0.3106798,0.05353856],[-0.44345278,-0.23122305,-0.62959856,-0.43062705,0.13194847,-0.60124606,-0.62745696,0.12254918,-0.09806103,-0.45324165]],
dtype=float32)>]Bereitgestellt von
Du kannst mehrere Layer komponieren, indem du die Model‑Klasse aus tf.keras erweiterst. Mehr zum Zusammensetzen von Modellen findest du hier.
5. Mehr Flexibilität beim Training
TensorFlow nutzt automatische Differenzierung, um die Gradienten der Loss‑Funktion bezüglich der Modellparameter zu berechnen. tf.GradientTape erstellt einen Kontext, in dem TensorFlow die Gradienten der Operationen mitprotokolliert. Zur Veranschaulichung definieren wir ein Modell auf Low‑Level‑Ebene, indem wir tf.keras.Model erweitern.
from tensorflow.keras import Model
classCustomModel(Model):def__init__(self):super(CustomModel, self).__init__()
self.do1 = tf.keras.layers.Dropout(rate=0.2, input_shape=(14,))
self.fc1 = tf.keras.layers.Dense(units=64, activation='relu')
self.do2 = tf.keras.layers.Dropout(rate=0.2)
self.fc2 = tf.keras.layers.Dense(units=64, activation='relu')
self.do3 = tf.keras.layers.Dropout(rate=0.2)
self.out = tf.keras.layers.Dense(units=1, activation='sigmoid')defcall(self, x):
x = self.do1(x)
x = self.fc1(x)
x = self.do2(x)
x = self.fc2(x)
x = self.do3(x)return self.out(x)
model = CustomModel()Bereitgestellt von
Die Topologie entspricht exakt dem zuvor definierten Modell. Um es mit automatischer Differenzierung zu trainieren, definieren wir Loss‑Funktion und Optimierer entsprechend:
loss_func = tf.keras.losses.BinaryCrossentropy()
optimizer = tf.keras.optimizers.Adam()Bereitgestellt von
Als Nächstes definierst du Metriken, mit denen du während des Trainings die Performance des Netzes misst – konkret Loss und Accuracy.
# Average the loss across the batch size within an epoch
train_loss = tf.keras.metrics.Mean(name='train_loss')
train_acc = tf.keras.metrics.BinaryAccuracy(name='train_acc')
valid_loss = tf.keras.metrics.Mean(name='test_loss')
valid_acc = tf.keras.metrics.BinaryAccuracy(name='valid_acc')Bereitgestellt von
tf.data bietet Utility‑Methoden zum Aufbau von Eingabepipelines – besonders nützlich bei großen Datenmengen.
Jetzt definierst du den Datengenerator, der beim Training Batches liefert.
Jetzt kannst du mit tf.GradientTape trainieren. Zuerst definieren wir eine Methode, die das Modell mit den per tf.data.DataSet bereitgestellten Daten trainiert. Wir dekorieren die Trainingsschritte mit tf.function, um den Geschwindigkeitsvorteil zu nutzen.
Modelltraining und Validierung
# Train the model@tf.functiondefmodel_train(features, labels):# Define the GradientTape contextwith tf.GradientTape()as tape:# Get the probabilities
predictions = model(features)# Calculate the loss
loss = loss_func(labels, predictions)# Get the gradients
gradients = tape.gradient(loss, model.trainable_variables)# Update the weights
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
train_loss(loss)
train_acc(labels, predictions)Bereitgestellt von
# Validating the model@tf.functiondefmodel_validate(features, labels):
predictions = model(features)
t_loss = loss_func(labels, predictions)
valid_loss(t_loss)
valid_acc(labels, predictions)Bereitgestellt von
Nutze die beiden Methoden, um das Modell fünf Epochen lang zu trainieren und zu validieren.
for epoch inrange(5):for features, labels in train_ds:
model_train(features, labels)for test_features, test_labels in test_ds:
model_validate(test_features, test_labels)
template ='Epoch {}, train_loss: {}, train_acc: {}, train_loss: {}, test_acc: {}'print(template.format(epoch+1,
train_loss.result(),
train_acc.result()*100,
valid_loss.result(),
valid_acc.result()*100))Bereitgestellt von
Dieses Beispiel ist inspiriert von diesem Beispiel der Autorinnen und Autoren von TensorFlow 2.0.
6. TensorFlow Datasets
Ein separates Modul namens DataSets hilft dir, elegant mit dem Netzwerkmodell zu arbeiten. Du hast es oben bereits gesehen. In diesem Abschnitt lädst du MNIST genau so, wie du es brauchst.
Du installierst die Bibliothek tensorflow_datasets mit pip. Danach kannst du loslegen. Sie bringt diverse Hilfsfunktionen mit, um flexibel deine Datenpipeline aufzusetzen. Mehr dazu findest du hier und hier. So baust du eine Input‑Pipeline für MNIST:
import tensorflow_datasets as tfds
# You can fetch the DatasetBuilder class by string
mnist_builder = tfds.builder("mnist")# Download the dataset
mnist_builder.download_and_prepare()# Construct a tf.data.Dataset: train and test
ds_train, ds_test = mnist_builder.as_dataset(split=[tfds.Split.TRAIN, tfds.Split.TEST])Bereitgestellt von
Die Warnung kannst du ignorieren. Beachte, wie elegant tensorflow_datasets die Pipeline handhabt.
# Prepare batches of 128 from the training set
ds_train = ds_train.batch(128)# Load in the dataset in the simplest way possiblefor features in ds_train:
image, label = features["image"], features["label"]Bereitgestellt von
Jetzt kannst du das erste Bild aus der geladenen Sammlung anzeigen. Hinweis:tensorflow_datasets funktioniert sowohl im Eager‑ als auch im Graph‑Modus.
import matplotlib.pyplot as plt
%matplotlib inline
# You can convert a TensorFlow tensor just by using# .numpy()
plt.imshow(image[0].numpy().reshape(28,28), cmap=plt.cm.binary)
plt.show()Bereitgestellt von
7. Automatic Mixed Precision Policy
Die Mixed‑Precision‑Policy wurde letztes Jahr von NVIDIA vorgeschlagen. Das Originalpaper findest du hier. Kurz gesagt mischt man Halbpräzision (FP16) und Vollpräzision (FP32), um die Vorteile beider Welten zu nutzen. Das beschleunigt das Training sehr tiefer Netze teils erheblich und verbessert teils auch die Scores.
Wenn du eine CUDA‑fähige GPU‑Umgebung nutzt (z. B. Volta‑Generation, Tesla T4) und die GPU‑Variante von TensorFlow 2.0 installiert hast, kannst du TensorFlow Mixed Precision wie folgt aktivieren:
TensorFlow passt dann automatisch Casts in den Graph‑Operationen an. Du wirst meist einen deutlichen Performance‑Boost sehen. Auch Kernoperationen lassen sich mit Mixed Precision optimieren. Mehr dazu in diesem Artikel.
TensorFlow 2.0 macht es sehr einfach, das Training über mehrere GPUs zu verteilen. Das ist vor allem in der Produktion hilfreich, wenn hohe Lasten zu stemmen sind. Du packst deinen Trainingscode einfach in einen with‑Block.
Die Mirrored Strategy erstellt je GPU eine Replik und spiegelt die Modellvariablen über alle GPUs. Du nutzt die Strategie dann so:
with mirrored_strategy.scope():
model = tf.keras.Sequential([tf.keras.layers.Dense(1, input_shape=(1,))])
model.compile(loss='mse', optimizer='sgd')
model.fit(X_train, y_train,
validation_data=(X_test, y_test),
batch_size=128,
epochs=10)Bereitgestellt von
Hinweis: Der Code bringt nur etwas, wenn mehrere GPUs in einem System konfiguriert sind. Es gibt mehrere Distributionsstrategien, die du konfigurieren kannst. Mehr dazu hier.
9. TensorBoard im Jupyter Notebook
Das ist wahrscheinlich das spannendste Update. Du kannst das Training direkt im Jupyter Notebook mit TensorBoard visualisieren. Das neue TensorBoard bringt viele Highlights wie Memory‑Profiling, Bilddaten inkl. Confusion‑Matrix, konzeptionelle Modellgraphen und mehr. Details findest du hier.
In diesem Abschnitt richtest du deine Umgebung so ein, dass TensorBoard im Notebook angezeigt wird. Zuerst lädst du die Erweiterung tensorboard.notebook:
Dann definierst du den TensorBoard‑Callback aus tf.keras.callbacks.
from datetime import datetime
import os
# Make a directory to keep the training logs
os.mkdir("logs")# Set the callback
logdir ="logs"
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=logdir)Bereitgestellt von
Baue das Modell mit der Sequential‑API von tf.keras neu auf:
# Define the model
model = tf.keras.Sequential([
tf.keras.layers.Dropout(rate=0.2, input_shape=X_train.shape[1:]),
tf.keras.layers.Dense(units=64, activation='relu'),
tf.keras.layers.Dropout(rate=0.2),
tf.keras.layers.Dense(units=64, activation='relu'),
tf.keras.layers.Dropout(rate=0.2),
tf.keras.layers.Dense(units=1, activation='sigmoid')])# Compile the model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])Bereitgestellt von
Da wir Train‑ und Testset für Verschiedenes angepasst hatten, splitten wir sie noch einmal neu:
# Split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=7)Bereitgestellt von
Alles bereit fürs Training:
# The TensorBoard extension%tensorboard --logdir logs/# Pass the TensorBoard callback you defined
model.fit(X_train, y_train,
validation_data=(X_test, y_test),
batch_size=64,
epochs=10,
callbacks=[tensorboard_callback],
verbose=False)Bereitgestellt von
<iframe
width="100%"
height="800"
src="http://localhost:6006"
frameborder="0"
allowfullscreen
></iframe><tensorflow.python.keras.callbacks.History at 0x7fc215b69400>Bereitgestellt von
Das TensorBoard‑Dashboard sollte nun im Notebook erscheinen, und du kannst Trainings‑ und Validierungsmetriken nachverfolgen.
10. TensorFlow für Swift
Bei allem Erfolg hat Python einen großen Nachteil: Es ist langsam. Um Forschenden, Praktikern und Einsteigern entgegenzukommen, hat das TensorFlow‑Team eine Variante für Swift entwickelt. Sie ist zwar noch nicht so produktionsreif wie die Python‑Version, hat aber großes Potenzial. Swift erlaubt mehr Low‑Level‑Kontrolle und fortgeschrittene Kompilierung. Alles zur Swift‑Variante von TensorFlow findest du hier. Sehenswert ist auch dieses Interview mit Jeremy Howard von Josh Gordon, in dem Jeremy seine Sicht auf diese Richtung teilt.
Wie geht’s weiter?
Du bist am Ende des Artikels angekommen. Die Stärke von Deep Learning liegt in der Anwendung. Dein nächster Schritt: Probiere die hier besprochenen Ideen aus und setze sie ein. Dieses TensorFlow‑Update gehört zu den umfangreichsten und entwicklerfreundlichsten bisher. Schau dir auch die YouTube‑Playlist des diesjährigen TensorFlow Dev Summit an – mit weiteren Updates zu TensorFlow lattice, TensorFlow probability, TensorFlow lite und mehr.
Wenn du deine Deep‑Learning‑Kenntnisse ausbauen möchtest, sieh dir diese Kurse an:
Lerne mehr über Python-Lambda-Funktionen, wozu sie gut sind und wann man sie benutzt. Enthält praktische Beispiele und bewährte Methoden für eine effektive Umsetzung.
Mach dich mit Python-Datenstrukturen vertraut: Lerne mehr über Datentypen und primitive sowie nicht-primitive Datenstrukturen wie Strings, Listen, Stapel usw.
Lerne, wie du Zahlen in Python mit round(), f-Strings, format(), dem decimal-Modul, NumPy und mehr auf zwei Dezimalstellen rundest — inklusive Vergleichstabelle der Methoden.
TensorFlow 2.0 alphaist erschienen. Das Framework hat einen enormen Einfluss auf die Deep‑Learning‑Community. Praktiker, Forschende und Entwickler lieben es und haben es so stark übernommen wie nie zuvor. Es ist einer der Hauptgründe für den rasanten Aufschwung all der coolen Deep‑Learning‑Anwendungen, die wir heute sehen. Gleichzeitig hatTensorFlow 1.xseine Schattenseiten (wie viele andere Frameworks auch). Wie Martin Wicke (Software Engineer imTensorFlow‑Team) auf dem TF Dev Summit ’19 sagte:Aus all den Learnings aus der großen Nutzerbasis und den GitHub‑Issues hat das
TensorFlow‑Team dieTensorFlow 2.0 alphaveröffentlicht – mit vielen wichtigen Änderungen für mehr Performance, bessere Developer Experience und mehr. Du kannst damit schneller Prototypen bauen und profitierst von zahlreichen modernen Deep‑Learning‑Best‑Practices. In diesem Artikel lernst du einige dieser Änderungen anhand kompakter Implementierungen kennen.Hinweis: Die hier besprochenen Updates sind aus Sicht des Autors die wichtigsten. Du solltest bereits Erfahrung mit
TensorFlowundKerasmitbringen, um dem Artikel gut folgen zu können. Folgende Ressourcen sind hilfreich, wenn du dein Wissen zuTensorFlowundKerasauffrischen möchtest:Installation und ein Demo‑Datensatz
Auf
TensorFlow 2.0aktualisierst du in Jupyter Notebook mit folgender Codezeile:!pip install tensorflow==2.0.0-alpha0Die GPU‑Variante installierst du analog (benötigt vorher CUDA):
!pip install tensorflow-gpu==2.0.0-alpha0Mehr zum Installationsprozess findest du hier.
Einige der Updates enthalten Codebeispiele. Dafür brauchst du einen Datensatz. In diesem Artikel verwenden wir den Adult‑Datensatz aus dem UCI‑Archiv.
Der Datensatz stellt eine binäre Klassifikationsaufgabe dar: Aus persönlichen Merkmalen soll vorhergesagt werden, ob eine Person mehr als 50.000 $ pro Jahr verdient oder nicht.
Lass uns etwas Basis‑Preprocessing machen und dann im Verhältnis 80:20 splitten:
Jetzt solltest du eine lauffähige Umgebung mit installiertem
TensorFlow 2.0und den Datensatz im Workspace haben. Weiter geht’s mit den Updates.1. Eager Execution standardmäßig aktiviert
In
TensorFlow 2.0musst du keine Session mehr erstellen und den Rechen‑Graph darin ausführen. Die Eager Execution ist in 2.0 standardmäßig aktiv, sodass du Modelle bauen und sofort ausführen kannst. Du kannst Eager Execution auch deaktivieren:tf.compat.v1.disable_eager_execution()(vorausgesetzt,tensorflowist alstfimportiert.)Hier ein kleiner Code‑Vergleich, der den Unterschied zeigt:
2. tf.function und AutoGraph
Eager Execution ermöglicht imperatives Programmieren. Bei verteiltem Training, umfassender Optimierung und in Produktionsumgebungen hat die Graph‑Ausführung im Stil von
TensorFlow 1.xaber Vorteile. InTensorFlow 2.0bleibt die Graph‑Ausführung erhalten – flexibler umgesetzt übertf.functionundAutoGraph.tf.functionerlaubt dir,TensorFlow‑Graphs mit Python‑ähnlicher Syntax überAutoGraphzu definieren.AutoGraphunterstützt vieles aus Python wieif‑Statements,for‑ undwhile‑Schleifen,Iteratorenusw., mit gewissen Einschränkungen. Eine vollständige Liste der aktuell unterstützten Konstrukte findest du in der Doku. Unten siehst du, wie einfach sich einTensorFlow‑Graph perDecoratordefinieren lässt.Beachte, dass du keine Sessions oder Placeholders brauchst, um
single_layer()auszuführen. Das ist eine der praktischen Stärken vontf.function. Unter der Haube optimiert TensorFlow den Code, damit er schneller läuft.3.
tf.variable_scopewird nicht mehr benötigtIn
TensorFlow 1.xmusstest du für wiederverwendbaretf.layersmit Variablen einentf.variable‑Block nutzen. InTensorFlow 2.0ist das dankkerasals zentrale High‑Level‑API nicht mehr nötig. Alle mittf.layerserstellten Layer kannst du direkt in einertf.keras.Sequential‑Defintion bündeln. Das macht den Code lesbarer, und du behältst Variablen und Losses im Blick.Hier ein Beispiel:
Im Beispiel leitest du die Trainingsdaten einmal durchs
model, um die rohen Ausgabewahrscheinlichkeiten zu erhalten. Das ist nur der Vorwärtsdurchlauf. Du kannst das Modell natürlich auch trainieren:Die trainierbaren Parameter des Modells kannst du layerweise wie folgt anzeigen:
4. Eigene Layer so einfach wie nie
In der Forschung wie auch in der Praxis brauchst du oft eigene Layer für spezielle Anwendungsfälle.
TensorFlow 2.0macht das Schreiben und Einbinden individueller Layer extrem einfach. Du kannst auch den Forward Pass deines Modells frei anpassen.Am leichtesten erstellst du einen Custom‑Layer, indem du die
Layer‑Klasse austf.keras.layerserweiterst und entsprechend definierst. Du legst einen eigenen Layer an und spezifizierst seine Vorwärtsberechnung. Die Ausgabe vonhelp(tf.keras.layers.Layer)zeigt dir, was du dafür angeben musst:Auf Basis dieses Hinweises wirst du:
build()die Gewichte für deinen Layer hinzufügencall()den Forward Pass über Matrixmultiplikation undrelu()definierenDu kannst mehrere Layer komponieren, indem du die
Model‑Klasse austf.keraserweiterst. Mehr zum Zusammensetzen von Modellen findest du hier.5. Mehr Flexibilität beim Training
TensorFlownutzt automatische Differenzierung, um die Gradienten der Loss‑Funktion bezüglich der Modellparameter zu berechnen.tf.GradientTapeerstellt einen Kontext, in demTensorFlowdie Gradienten der Operationen mitprotokolliert. Zur Veranschaulichung definieren wir ein Modell auf Low‑Level‑Ebene, indem wirtf.keras.Modelerweitern.Die Topologie entspricht exakt dem zuvor definierten Modell. Um es mit automatischer Differenzierung zu trainieren, definieren wir Loss‑Funktion und Optimierer entsprechend:
Als Nächstes definierst du Metriken, mit denen du während des Trainings die Performance des Netzes misst – konkret Loss und Accuracy.
tf.databietet Utility‑Methoden zum Aufbau von Eingabepipelines – besonders nützlich bei großen Datenmengen.Jetzt definierst du den Datengenerator, der beim Training Batches liefert.
Jetzt kannst du mit
tf.GradientTapetrainieren. Zuerst definieren wir eine Methode, die das Modell mit den pertf.data.DataSetbereitgestellten Daten trainiert. Wir dekorieren die Trainingsschritte mittf.function, um den Geschwindigkeitsvorteil zu nutzen.Modelltraining und Validierung
Nutze die beiden Methoden, um das Modell fünf Epochen lang zu trainieren und zu validieren.
Dieses Beispiel ist inspiriert von diesem Beispiel der Autorinnen und Autoren von
TensorFlow 2.0.6. TensorFlow Datasets
Ein separates Modul namens
DataSetshilft dir, elegant mit dem Netzwerkmodell zu arbeiten. Du hast es oben bereits gesehen. In diesem Abschnitt lädst du MNIST genau so, wie du es brauchst.Du installierst die Bibliothek
tensorflow_datasetsmitpip. Danach kannst du loslegen. Sie bringt diverse Hilfsfunktionen mit, um flexibel deine Datenpipeline aufzusetzen. Mehr dazu findest du hier und hier. So baust du eine Input‑Pipeline für MNIST:Die Warnung kannst du ignorieren. Beachte, wie elegant
tensorflow_datasetsdie Pipeline handhabt.Jetzt kannst du das erste Bild aus der geladenen Sammlung anzeigen. Hinweis:
tensorflow_datasetsfunktioniert sowohl im Eager‑ als auch im Graph‑Modus.7. Automatic Mixed Precision Policy
Die Mixed‑Precision‑Policy wurde letztes Jahr von NVIDIA vorgeschlagen. Das Originalpaper findest du hier. Kurz gesagt mischt man Halbpräzision (FP16) und Vollpräzision (FP32), um die Vorteile beider Welten zu nutzen. Das beschleunigt das Training sehr tiefer Netze teils erheblich und verbessert teils auch die Scores.
Wenn du eine CUDA‑fähige GPU‑Umgebung nutzt (z. B. Volta‑Generation, Tesla T4) und die GPU‑Variante von
TensorFlow 2.0installiert hast, kannst duTensorFlowMixed Precision wie folgt aktivieren:os.environ['TF_ENABLE_AUTO_MIXED_PRECISION'] = '1'TensorFlow passt dann automatisch Casts in den Graph‑Operationen an. Du wirst meist einen deutlichen Performance‑Boost sehen. Auch Kernoperationen lassen sich mit Mixed Precision optimieren. Mehr dazu in diesem Artikel.
Wichtig: Dieses Feature wird nur im TensorFlow‑Docker‑Container von NVIDIA unterstützt. Für eine native Integration von Mixed‑Precision‑Training in tf.keras schau dir diesen Artikel an. Danke an Abhishek Thanki für den Hinweis.
8. Verteiltes Training
TensorFlow 2.0macht es sehr einfach, das Training über mehrere GPUs zu verteilen. Das ist vor allem in der Produktion hilfreich, wenn hohe Lasten zu stemmen sind. Du packst deinen Trainingscode einfach in einenwith‑Block.Zuerst legst du eine Distributionsstrategie fest:
mirrored_strategy = tf.distribute.MirroredStrategy()Die Mirrored Strategy erstellt je GPU eine Replik und spiegelt die Modellvariablen über alle GPUs. Du nutzt die Strategie dann so:
Hinweis: Der Code bringt nur etwas, wenn mehrere GPUs in einem System konfiguriert sind. Es gibt mehrere Distributionsstrategien, die du konfigurieren kannst. Mehr dazu hier.
9. TensorBoard im Jupyter Notebook
Das ist wahrscheinlich das spannendste Update. Du kannst das Training direkt im Jupyter Notebook mit
TensorBoardvisualisieren. Das neueTensorBoardbringt viele Highlights wie Memory‑Profiling, Bilddaten inkl. Confusion‑Matrix, konzeptionelle Modellgraphen und mehr. Details findest du hier.In diesem Abschnitt richtest du deine Umgebung so ein, dass
TensorBoardim Notebook angezeigt wird. Zuerst lädst du die Erweiterungtensorboard.notebook:Dann definierst du den
TensorBoard‑Callback austf.keras.callbacks.Baue das Modell mit der
Sequential‑API vontf.kerasneu auf:Da wir Train‑ und Testset für Verschiedenes angepasst hatten, splitten wir sie noch einmal neu:
Alles bereit fürs Training:
Das
TensorBoard‑Dashboard sollte nun im Notebook erscheinen, und du kannst Trainings‑ und Validierungsmetriken nachverfolgen.10. TensorFlow für Swift
Bei allem Erfolg hat Python einen großen Nachteil: Es ist langsam. Um Forschenden, Praktikern und Einsteigern entgegenzukommen, hat das
TensorFlow‑Team eine Variante für Swift entwickelt. Sie ist zwar noch nicht so produktionsreif wie die Python‑Version, hat aber großes Potenzial. Swift erlaubt mehr Low‑Level‑Kontrolle und fortgeschrittene Kompilierung. Alles zur Swift‑Variante von TensorFlow findest du hier. Sehenswert ist auch dieses Interview mit Jeremy Howard von Josh Gordon, in dem Jeremy seine Sicht auf diese Richtung teilt.Wie geht’s weiter?
Du bist am Ende des Artikels angekommen. Die Stärke von Deep Learning liegt in der Anwendung. Dein nächster Schritt: Probiere die hier besprochenen Ideen aus und setze sie ein. Dieses
TensorFlow‑Update gehört zu den umfangreichsten und entwicklerfreundlichsten bisher. Schau dir auch die YouTube‑Playlist des diesjährigenTensorFlowDev Summit an – mit weiteren Updates zuTensorFlow lattice,TensorFlow probability,TensorFlow liteund mehr.Wenn du deine Deep‑Learning‑Kenntnisse ausbauen möchtest, sieh dir diese Kurse an:
Happy
eager_executing!