GSP631

Übersicht

TensorFlow ist eine leistungsstarke, portierbare Open-Source-Bibliothek für maschinelles Lernen (ML), die von Google entwickelt wurde und für das Arbeiten mit sehr großen Datasets geeignet ist. In diesem Lab erstellen und trainieren Sie mit TensorFlow Vertex AI Workbench ein Modell für maschinelles Sehen, das verschiedene Kleidungsstücke erkennen soll.

Einführung in TensorFlow

TensorFlow bietet ein Rechensystem zum Erstellen von ML-Modellen. Dieses beinhaltet verschiedene Toolkits, mit denen Sie Modelle auf Ihrer bevorzugten Abstraktionsebene entwickeln können. In diesem Lab nutzen Sie tf.keras, eine allgemeine API, um in TensorFlow ein neuronales Netzwerk zum Klassifizieren von Bildern zu erstellen und zu trainieren.

Neuronale Netzwerke

Ein neuronales Netzwerk ist ein vom Gehirn inspiriertes Modell. Es besteht aus mehreren Ebenen, von denen mindestens eine verborgen ist, und diese wiederum umfassen einfache, vernetzte Einheiten oder Neuronen, gefolgt von Nichtlinearitäten.

Ein Knoten in einem neuronalen Netzwerk empfängt in der Regel mehrere Eingabewerte und erzeugt einen Ausgabewert. Das Neuron wendet auf eine gewichtete Summe von Eingabewerten eine Aktivierungsfunktion (nicht lineare Transformation) an, um den Ausgabewert zu berechnen.

Weitere Informationen zu neuronalen Netzwerken finden Sie unter Neuronale Netzwerke: Knoten und verborgene Ebenen.

Lernziele

Aufgaben in diesem Lab:

• Tensorflow-Modell entwerfen, kompilieren, trainieren und evaluieren
• Modelle speichern und laden
• Eigene Callbacks schreiben, um das Verhalten während des Trainings anzupassen
• Reihe von Übungen absolvieren, in denen mit den verschiedenen Ebenen des Netzwerks experimentiert wird

Einrichtung und Anforderungen

Vor dem Klick auf „Start Lab“ (Lab starten)

Lesen Sie diese Anleitung. Labs sind zeitlich begrenzt und können nicht pausiert werden. Der Timer beginnt zu laufen, wenn Sie auf Lab starten klicken, und zeigt Ihnen, wie lange Google Cloud-Ressourcen für das Lab verfügbar sind.

In diesem praxisorientierten Lab können Sie die Lab-Aktivitäten in einer echten Cloud-Umgebung durchführen – nicht in einer Simulations- oder Demo-Umgebung. Dazu erhalten Sie neue, temporäre Anmeldedaten, mit denen Sie für die Dauer des Labs auf Google Cloud zugreifen können.

Für dieses Lab benötigen Sie Folgendes:

• Einen Standardbrowser (empfohlen wird Chrome)

Hinweis: Nutzen Sie den privaten oder Inkognitomodus (empfohlen), um dieses Lab durchzuführen. So wird verhindert, dass es zu Konflikten zwischen Ihrem persönlichen Konto und dem Teilnehmerkonto kommt und zusätzliche Gebühren für Ihr persönliches Konto erhoben werden.

• Zeit für die Durchführung des Labs – denken Sie daran, dass Sie ein begonnenes Lab nicht unterbrechen können.

Hinweis: Verwenden Sie für dieses Lab nur das Teilnehmerkonto. Wenn Sie ein anderes Google Cloud-Konto verwenden, fallen dafür möglicherweise Kosten an.

Aufgabe 1: Notebook in Vertex AI Workbench öffnen

1. Klicken Sie in der Google Cloud Console im Navigationsmenü () auf Vertex AI > Workbench.

2. Suchen Sie die Instanz und klicken Sie auf JupyterLab öffnen.

Die JupyterLab-Oberfläche für Ihre Workbench-Instanz wird in einem neuen Browsertab geöffnet.

Hinweis: Wenn in JupyterLab keine Notebooks angezeigt werden, führen Sie die folgenden zusätzlichen Schritte aus, um die Instanz zurückzusetzen:

1. Schließen Sie den Browsertab für JupyterLab und kehren Sie zur Workbench-Startseite zurück.

2. Aktivieren Sie das Kästchen neben dem Instanznamen und klicken Sie dann auf Zurücksetzen.

3. Nachdem die Schaltfläche JupyterLab öffnen wieder aktiviert ist, warten Sie eine Minute und klicken Sie dann auf JupyterLab öffnen.

TensorFlow und zusätzliche Pakete installieren

1. Wählen Sie im Launcher-Menü unter Sonstiges die Option Terminal aus.

2. Prüfen Sie, ob die Python-Umgebung schon konfiguriert ist. Kopieren Sie den folgenden Befehl und fügen Sie ihn in das Terminal ein:

python --version

Beispielausgabe:

Python 3.10.14

3. Führen Sie den folgenden Befehl aus, um das TensorFlow-Paket zu installieren:

pip3 install tensorflow

4. Führen Sie im Terminal den folgenden Befehl aus, um ein Upgrade von pip3 durchzuführen:

pip3 install --upgrade pip

Pylint ist ein Tool, mit dem sich Fehler in Python-Code finden lassen. Es kennzeichnet syntaktische und stilistische Probleme in Python-Quellcode.

5. Führen Sie den folgenden Befehl aus, um das pylint-Paket zu installieren:

pip install -U pylint --user

6. Installieren Sie die für das Lab erforderlichen Pakete in der Datei requirements.txt:

pip install -r requirements.txt

Damit haben Sie die Umgebung eingerichtet.

Aufgabe 2: Neues Notebook erstellen und Bibliotheken importieren

1. Klicken Sie links in der Workbench auf das +-Zeichen, um einen neuen Launcher zu öffnen.

2. Wählen Sie im Launcher-Menü unter Notebook die Option Python3 aus.

Ihnen wird ein neues Jupyter-Notebook angezeigt. Weitere Informationen zum Verwenden von Jupyter-Notebooks, finden Sie in der Jupyter Notebook-Dokumentation.

3. Importieren und konfigurieren Sie logging und google-cloud-logging für Cloud Logging. Fügen Sie den folgenden Code in die erste Zelle ein:

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging cloud_logger = logging.getLogger('cloudLogger') cloud_logger.setLevel(logging.INFO) cloud_logger.addHandler(CloudLoggingHandler(cloud_logging.Client())) cloud_logger.addHandler(logging.StreamHandler())

4. Importieren Sie tensorflow zum Trainieren und Evaluieren des Modells. Legen Sie als einfach zu merkende Bezeichnung tf fest. Fügen Sie den folgenden Code in die erste Zelle ein:

# Import TensorFlow import tensorflow as tf

5. Importieren Sie numpy, um die Daten zur Fehlerbehebung zu parsen. Legen Sie als einfach zu merkende Bezeichnung np fest. Fügen Sie in der ersten Zelle den folgenden Code hinzu:

# Import numpy import numpy as np

6. Fügen Sie den folgenden Code in die erste Zelle ein, um tensorflow_datasets zum Einbinden des Datasets zu importieren. TensorFlow Datasets ist eine Reihe sofort einsatzbereiter Datasets für TensorFlow.

Informationen zur Verwendung finden Sie im Leitfaden und der Liste der Datasets. # Import tensorflow_datasets import tensorflow_datasets as tfds

7. Klicken Sie auf Ausführen oder drücken Sie Umschalttaste + Eingabetaste, um die Zelle auszuführen.

8. Speichern Sie das Notebook. Klicken Sie dazu auf Datei > Speichern. Geben Sie der Datei den Namen model.ipynb und klicken Sie auf Ok.

Aufgabe 3: Dataset laden und vorverarbeiten

Über das Dataset

Sie trainieren anhand eines Datasets namens Fashion MNIST ein neuronales Netzwerk zum Klassifizieren von Bildern von Kleidungsstücken.

Dieses Dataset umfasst 70.000 Kleidungsstücke aus zehn verschiedenen Kategorien. Auf den Bildern sind einzelne Kleidungsstücke in niedriger Auflösung (28 × 28 Pixel) zu sehen. Hier ein Beispiel:

In diesem Lab werden 60.000 Bilder dazu verwendet, das Netzwerk zu trainieren, und anhand von 10.000 Bilder wird evaluiert, wie gut das Netzwerk gelernt hat, Bilder zu klassifizieren.

Die Fashion MNIST-Daten stehen unter tensorflow datasets(tfds) zur Verfügung.

Dataset laden

Sie verwenden zum Laden der Fashion MNIST-Daten die Funktion tfds.load().

1. Fügen Sie den folgenden Code in die zweite Zelle des Notebooks ein:

# Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True)

Im obigen Code legen Sie mit dem Argument split fest, welche Splits des Datasets geladen werden sollen. Setzen Sie as_supervised auf True, um sicherzustellen, dass das geladene Dataset tf.data.Dataset eine Struktur mit zwei Tupeln (input, label) hat.

ds_train und ds_test sind vom Typ tf.data.Dataset. ds_train umfasst 60.000 Bilder, die für das Training des Modells verwendet werden. Die 10.000 Bilder aus ds_test dienen dazu, das Modell zu evaluieren.

Weitere Informationen zu tfds.load() und den zugehörigen Argumenten finden Sie im Leitfaden.

Wie sehen die Werte aus?

2. Als Nächstes fügen Sie Ausgabeanweisungen hinzu, um die Mindest- und Höchstwerte der Trainingsbilder für Element 0 zu sehen. Fügen Sie den folgenden Code in die zweite Zelle ein:

# Values before normalization image_batch, labels_batch = next(iter(ds_train)) print("Before normalization ->", np.min(image_batch[0]), np.max(image_batch[0]))

Datenvorverarbeitung

1. Batchgröße ist ein im maschinellen Lernen verwendeter Begriff, mit dem die Anzahl der in einer Iteration verwendeten Trainingsbeispiele bezeichnet wird. Sie legen hierfür den Wert 32 fest.

Definieren Sie die Batchgröße, indem Sie Folgendes zu model.ipynb hinzufügen:

# Define batch size BATCH_SIZE = 32

2. Beim Trainieren eines neuronalen Netzwerks ist es aus verschiedenen Gründen einfacher, die Pixelwerte auf einen Bereich zwischen 0 und 1 zu skalieren. Dieser Vorgang wird als Normalisierung bezeichnet. Da die Pixelwerte des Fashion MNIST-Datasets im Bereich [0, 255] liegen, teilen Sie sie durch 255,0, um die Bilder zu normalisieren.

Im unten dargestellten Code wird die Funktion map() von tf.data.Dataset verwendet, um die Bilder in ds_train und ds_test zu normalisieren. Da die Pixelwerte vom Typ tf.uint8 sind, werden sie mit der Funktion tf.cast in tf.float32 konvertiert und dann durch 255,0 geteilt. Außerdem wird das Dataset durch Aufrufen der Methode batch() mit BATCH_SIZE als Argument in Batches umgewandelt.

Informationen zu allen verfügbaren Methoden für tf.data.Dataset finden Sie hier.

Fügen Sie am Ende der Datei den folgenden Code ein:

# Normalize and batch process the dataset ds_train = ds_train.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) ds_test = ds_test.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE)

3. Lassen Sie die Mindest- und Höchstwerte eines Bildes im Trainings-Dataset noch einmal ausgeben.

Fügen Sie am Ende der Datei den folgenden Code ein:

# Examine the min and max values of the batch after normalization image_batch, labels_batch = next(iter(ds_train)) print("After normalization ->", np.min(image_batch[0]), np.max(image_batch[0]))

Aufgabe 4: Modell entwerfen, kompilieren und trainieren

In diesem Abschnitt entwerfen Sie das Modell mit TensorFlow.

1. Fügen Sie den folgenden Code in die Datei ein:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

Sehen Sie sich die verschiedenen Arten von Ebenen und die in der Modellarchitektur verwendeten Parameter an:

• Sequential: Damit wird eine SEQUENZ von Ebenen in einem neuronalen Netzwerk definiert.

• Flatten: Die Bilder haben die Form (28, 28), die Werte sind also in einer quadratischen Matrix angeordnet. Mit „Flatten“ wird daraus ein eindimensionaler Vektor.

• Dense: Fügt eine Neuronenebene hinzu.

Jede Neuronenebene erfordert eine Aktivierungsfunktion, um zu entscheiden, ob ein Neuron aktiviert werden soll oder nicht. Es gibt viele Optionen, aber in diesem Lab werden die folgenden verwendet:

• Relu bedeutet: Wenn X > 0, soll X zurückgegeben werden, ansonsten wird 0 zurückgegeben. Werte, die größer oder gleich 0 sind, werden an die nächste Netzwerkebene übergeben.
• Softmax wählt aus einer Gruppe von Werten den größten aus, damit Sie sie nicht sortieren müssen, um den größten zu finden. Wenn beispielsweise die Ausgabe der letzten Ebene [0.1, 0.1, 0.05, 0.1, 9.5, 0.1, 0.05, 0.05, 0.05] ist, wird [0,0,0,0,1,0,0,0,0] ausgegeben.

Modell kompilieren und trainieren

In diesem Abschnitt kompilieren Sie das Modell mit einer Optimizer- und Verlustfunktion. Anschließend trainieren Sie es mit Ihren Trainingsdaten und Labels.

Das Modell soll die Beziehung zwischen den Trainingsdaten und den Labels erkennen. Nach Abschluss des Trainings soll das Modell in der Lage sein, bei neuen Bildern von Kleidungsstücken, die den Trainingsdaten ähneln, Vorhersagen zu machen, zu welcher Kategorie von Kleidung sie gehören.

Ein Optimizer ist eines der beiden Argumente, die zum Kompilieren eines tf.keras-Modells nötig sind. Ein Optimizer ist ein Algorithmus, durch den die Attribute des neuronalen Netzwerks wie Gewichtungen und Lernrate geändert werden. Dadurch wird der Verlust reduziert und die Accuracy verbessert.

Informationen zu verschiedenen Arten von Optimizern in tf.keras finden Sie hier.

Loss gibt mit einer Zahl die Leistung des Modells an. Ist die Leistung des Modells hoch, wird als Verlust eine niedrige Zahl ausgegeben. Im gegenteiligen Fall wird der Verlust als hohe Zahl angegeben.

Informationen zu verschiedenen Arten von Verlustfunktionen in tf.keras finden Sie hier.

Beachten Sie den Parameter metrics=. Damit kann TensorFlow nach jeder Epoche einen Bericht zur Accuracy des Trainings erstellen, indem die vorhergesagten Ergebnisse anhand der bekannten Antworten (Labels) geprüft werden. Daran lässt sich praktisch ablesen, wie effektiv das Training läuft.

Details zu den verschiedenen Arten von Messwerten in „tf.keras“ finden Sie hier.

Model.fit trainiert das Model eine festgelegte Anzahl von Epochen lang.

1. Fügen Sie den folgenden Code in die Datei ein:

# Compile the model model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5)

Klicken Sie auf Fortschritt prüfen. Modelle für maschinelles Lernen erstellen

Code ausführen

1. Führen Sie die zweite Zelle aus, indem Sie auf Ausführen klicken oder Umschalttaste + Eingabetaste drücken.

Wenn die Notebook-Zelle ausgeführt wird, erhalten Sie nach jeder Trainingsepoche bzw. jedem Durchlauf eine Meldung zu Verlust und Accuracy. Wie Sie sehen, steigt die Accuracy nach jeder Epoche bzw. jedem Durchlauf:

Beispielausgabe (Ihre Werte können davon abweichen, Warnmeldungen können ignoriert werden):

Before normalization -> 0 227 After normalization -> 0.0 1.0 Epoch 1/5 1875/1875 [==============================] - 12s 6ms/step - loss: 0.5264 - sparse_categorical_accuracy: 0.8175 Epoch 2/5 1875/1875 [==============================] - 6s 3ms/step - loss: 0.3977 - sparse_categorical_accuracy: 0.8580 Epoch 3/5 1875/1875 [==============================] - 5s 3ms/step - loss: 0.3585 - sparse_categorical_accuracy: 0.8701 Epoch 4/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3329 - sparse_categorical_accuracy: 0.8784 Epoch 5/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3151 - sparse_categorical_accuracy: 0.8846

Bei der Ausgabe # Values before normalization liegen Mindest- und Höchstwert im Bereich [0, 255]. Nach der Normalisierung befinden sich alle Werte im Bereich [0, 1].

Im Lauf des Trainings sinkt der Verlust und die Accuracy steigt.

Wenn das Training des Modells abgeschlossen ist, wird Ihnen am Ende der Epoche ein Accuracy-Wert angezeigt. Möglicherweise liegt er wie oben bei etwa 0,8846, aber Ihr Accuracy-Wert kann davon abweichen.

Daran lässt sich ablesen, dass das neuronale Netzwerk die Trainingsdaten zu etwa 89 % korrekt klassifiziert. Mit anderen Worten: Es fand eine Musterübereinstimmung zwischen dem Bild und den Labels, die in 89 % der Fälle richtig war. Das ist nicht besonders gut, aber auch nicht schlecht, wenn man bedenkt, dass ein kleines neuronales Netzwerk nur fünf Epochen lang trainiert wurde.

Aufgabe 5: Leistung des Modells bei bisher ungesehenen Daten evaluieren

Aber wie schneidet das Modell bei Daten ab, die es noch nicht kennt?

Das Test-Dataset kann dazu beitragen, diese Frage zu beantworten. Sie rufen model.evaluate auf, übergeben die beiden Datasets und das Modell gibt den jeweiligen Verlust zurück.

Evaluieren Sie das Test-Dataset:

1. Fügen Sie den folgenden Code in die dritte Zelle des Notebooks ein:

cloud_logger.info(model.evaluate(ds_test))

2. Führen Sie die Zelle aus, indem Sie auf Ausführen klicken oder Umschalttaste + Eingabetaste drücken.

Wenn Sie an das Ende der Ausgabe scrollen, sehen Sie das Ergebnis der Evaluation in der letzten Zeile.

Before normalization -> 0 227 After normalization -> 0.0 1.0 Epoch 1/5 1875/1875 [==============================] - 12s 6ms/step - loss: 0.5264 - sparse_categorical_accuracy: 0.8175 Epoch 2/5 1875/1875 [==============================] - 6s 3ms/step - loss: 0.3977 - sparse_categorical_accuracy: 0.8580 Epoch 3/5 1875/1875 [==============================] - 5s 3ms/step - loss: 0.3585 - sparse_categorical_accuracy: 0.8701 Epoch 4/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3329 - sparse_categorical_accuracy: 0.8784 Epoch 5/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3151 - sparse_categorical_accuracy: 0.8846 313/313 [==============================] - 1s 4ms/step - loss: 0.3653 - sparse_categorical_accuracy: 0.8708 INFO:cloudLogger:[0.36530008912086487, 0.8708000183105469]

Das Modell meldet eine Accuracy von 0,8708 oder etwa 87 % für das Test-Dataset (ds_test). (Ihre Werte können leicht davon abweichen.)

Wie erwartet, war das Modell bei den unbekannten Daten nicht ganz so erfolgreich wie bei denen, mit denen es trainiert wurde.

Wenn Sie sich genauer mit TensorFlow befassen, lernen Sie Möglichkeiten kennen, dies zu verbessern.

Klicken Sie auf Fortschritt prüfen. Modell verwenden

Aufgabe 6: Modell speichern und laden

Der Modellfortschritt kann während des Trainings und danach gespeichert werden. So kann das Modell dort weitermachen, wo es aufgehört hat, was die Trainingszeit unter Umständen verkürzt. Das Speichern ermöglicht es Ihnen außerdem, Ihr Modell mit anderen zu teilen, damit diese ebenfalls damit arbeiten können. In dieser ersten Übung fügen Sie den notwendigen Code hinzu, um Ihr Modell zu speichern und zu laden.

Ein ganzes Modell kann in den Dateiformaten SavedModel und Keras gespeichert werden. Das Format TensorFlow SavedModel ist das Standarddateiformat in TF2.x. Alternativ kann aber auch das Format Keras verwendet werden. Sie erhalten später noch weitere Informationen zum Speichern von Modellen in den beiden Dateiformaten.

1. Fügen Sie den folgenden Code in die vierte Zelle des Notebooks ein:

# Save the entire model as a Keras model using .keras format model.save('saved_model.keras') # Load the model using custom_objects to handle the custom activation function new_model = tf.keras.models.load_model('saved_model.keras', custom_objects={'softmax_v2': tf.keras.activations.softmax}) # Summary of loaded SavedModel new_model.summary() # Save the entire model to a keras file. model.save('my_model.keras') # Recreate the exact same model, including its weights and the optimizer new_model_keras = tf.keras.models.load_model('my_model.keras', custom_objects={'softmax_v2': tf.keras.activations.softmax}) # Summary of loaded keras model new_model_keras.summary()

Der obige Code zeigt, wie Sie das Modell in zwei verschiedenen Formaten speichern und das gespeicherte Modell wieder laden können. Sie können das für Ihren Anwendungsfall geeignete Format auswählen. Weitere Informationen zu dieser Funktion finden Sie in der TensorFlow-Dokumentation unter „Save and load models“.

2. Führen Sie die Zelle aus, indem Sie auf Ausführen klicken oder Umschalttaste + Eingabetaste drücken.

Am Ende der Ausgabe sehen Sie zwei Modellzusammenfassungen. Die erste bezieht sich auf das im Format SavedModel gespeicherte Modell, bei der zweiten wurde das Modell im Format h5 gespeichert.

Wie Sie sehen, sind die Modellzusammenfassungen identisch, da wir dasselbe Modell in zwei verschiedenen Formaten gespeichert haben.

Model: "sequential" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= flatten (Flatten) (None, 784) 0 dense (Dense) (None, 64) 50240 dense_1 (Dense) (None, 10) 650 ================================================================= Total params: 50,890 Trainable params: 50,890 Non-trainable params: 0 _________________________________________________________________ Model: "sequential" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= flatten (Flatten) (None, 784) 0 dense (Dense) (None, 64) 50240 dense_1 (Dense) (None, 10) 650 ================================================================= Total params: 50,890 Trainable params: 50,890 Non-trainable params: 0 _________________________________________________________________

Klicken Sie auf Fortschritt prüfen. Modelle speichern und laden

Aufgabe 7: Callbacks kennenlernen

Beim Training des Modells ist Ihnen vermutlich aufgefallen, dass der Verlust immer kleiner und die Accuracy immer größer wurde. Nachdem die angepeilten Accuracy- und Verlustwerte erreicht wurden, dauert es aber möglicherweise noch etwas, bis das Training abgeschlossen ist.

Vielleicht denken Sie: „Wäre es nicht praktisch, das Training beenden zu können, wenn das Modell die gewünschte Accuracy erreicht hat?“

Wenn eine Accuracy von 95 % ausreicht und das Modell diese nach drei Trainingsepochen erreicht – warum sollte man dann noch viele weitere Epochen lang warten?

Die Lösung: Callbacks!

Ein Callback ist ein leistungsstarkes Tool zum Anpassen des Verhaltens eines Keras-Modells bei Training, Evaluation oder Inferenz. Sie können einen Callback definieren, um das Training zu beenden, sobald Ihr Modell die gewünschte Accuracy für das Trainings-Dataset erreicht hat.

Verwenden Sie den folgenden Code, um auszuprobieren, was geschieht, wenn Sie einen Callback einrichten, um das Training bei einer Accuracy von 84 % zu beenden:

1. Öffnen Sie den Launcher und wählen Sie Python3 aus, um ein neues Jupyter-Notebook zu erstellen.

2. Speichern Sie die Datei als callback_model.ipynb.

3. Fügen Sie den folgenden Code in die erste Zelle von callback_model.ipynb ein:

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging exp_logger = logging.getLogger('expLogger') exp_logger.setLevel(logging.INFO) exp_logger.addHandler(CloudLoggingHandler(cloud_logging.Client(), name="callback")) # Import tensorflow_datasets import tensorflow_datasets as tfds # Import numpy import numpy as np # Import TensorFlow import tensorflow as tf # Define Callback class myCallback(tf.keras.callbacks.Callback): def on_epoch_end(self, epoch, logs={}): if(logs.get('sparse_categorical_accuracy')>0.84): exp_logger.info("\nReached 84% accuracy so cancelling training!") self.model.stop_training = True callbacks = myCallback() # Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) ds_test = ds_test.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)]) # Compile data model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5, callbacks=[callbacks])

4. Drücken Sie Strg + S oder gehen Sie zu Datei > Notebook speichern, um die Änderungen zu speichern

5. Führen Sie den Code aus, indem Sie auf Ausführen klicken oder Umschalttaste + Eingabetaste drücken.

Wie Sie sehen, wurde das Training nach wenigen Epochen abgebrochen.

Klicken Sie auf Fortschritt prüfen. Callbacks kennenlernen

Aufgabe 8: Mit dem Modell experimentieren

In diesem Abschnitt experimentieren Sie mit den verschiedenen Netzwerkebenen.

Übung 1

In dieser Übung lernen Sie die Ebenen Ihres Modells näher kennen. Was geschieht, wenn Sie die Anzahl der Neuronen ändern?

1. Öffnen Sie den Launcher und wählen Sie Python3 aus, um ein neues Jupyter-Notebook zu erstellen.

2. Speichern Sie die Datei als updated_model.ipynb.

3. Fügen Sie den folgenden Code in die erste Zelle von updated_model.ipynb ein:

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging up_logger = logging.getLogger('upLogger') up_logger.setLevel(logging.INFO) up_logger.addHandler(CloudLoggingHandler(cloud_logging.Client(), name="updated")) # Import tensorflow_datasets import tensorflow_datasets as tfds # Import numpy import numpy as np # Import TensorFlow import tensorflow as tf # Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) ds_test = ds_test.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)]) # Compile data model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5) # Logs model summary model.summary(print_fn=up_logger.info)

4. Testen Sie verschiedene Werte für die Dense-Ebene.

Legen Sie im Abschnitt # Define the model 128 statt 64 Neuronen fest:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

4. Drücken Sie Strg + S oder gehen Sie zu Datei > Notebook speichern, um die Änderungen zu speichern

5. Führen Sie den Code aus, indem Sie auf Ausführen klicken oder Umschalttaste + Eingabetaste drücken.

Wie unterscheiden sich die Ergebnisse im Hinblick auf Verlust, Trainingszeit usw.? Was könnte der Grund sein?

Wenn Sie die Anzahl der Neuronen auf 128 erhöhen, sind mehr Berechnungen nötig. Das verlangsamt den Trainingsprozess. In diesem Fall hatte die Steigerung einen positiven Effekt, weil sich dadurch die Accuracy des Modells erhöht hat. Mehr ist aber nicht immer besser. Der Punkt, an dem die Ergebnisse den Aufwand nicht mehr rechtfertigen, kann schnell erreicht sein.

Klicken Sie auf Fortschritt prüfen. Übung 1

Übung 2

Jetzt testen Sie die Auswirkungen weiterer Ebenen im Netzwerk. Was geschieht, wenn Sie zwischen den beiden Dense-Ebenen eine weitere einfügen?

1. Fügen Sie in updated_model.ipynb im Abschnitt # Define the model eine weitere Ebene hinzu.

Ersetzen Sie Ihre Modelldefinition durch Folgendes:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Drücken Sie Strg + S oder gehen Sie zu Datei > Notebook speichern, um die Änderungen zu speichern

3. Führen Sie den Code aus, indem Sie auf Ausführen klicken oder Umschalttaste + Eingabetaste drücken.

Antwort: Dies hat keine signifikanten Auswirkungen, da es sich um relativ einfache Daten handelt. Bei deutlich komplexeren Daten sind zusätzliche Ebenen jedoch oft notwendig.

Klicken Sie auf Fortschritt prüfen. Übung 2

Übung 3

Bevor Sie das Modell trainiert haben, haben Sie die Pixelwerte im Bereich [0, 1] normalisiert. Welche Auswirkungen hätte es, wenn Sie die Normalisierung aufheben würden und die Werte im Bereich [0, 255] lägen, wie es ursprünglich im Dataset der Fall war?

1. Probieren Sie es aus! Entfernen Sie im Abschnitt # Define, load and configure data die map-Funktion, die bisher auf das Trainings- und Test-Dataset angewendet wurde.

# Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.batch(BATCH_SIZE) ds_test = ds_test.batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Fügen Sie diesen Code am Ende der Zelle hinzu, um den Höchstwert des ersten Bildes in Batch 0 auszugeben. Ohne Normalisierung liegt der Höchstwert im Bereich [0, 255].

# Print out max value to see the changes image_batch, labels_batch = next(iter(ds_train)) t_image_batch, t_labels_batch = next(iter(ds_test)) up_logger.info("training images max " + str(np.max(image_batch[0]))) up_logger.info("test images max " + str(np.max(t_image_batch[0])))

3. Die endgültige Datei updated_model.ipynb sieht in etwa so aus:

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging up_logger = logging.getLogger('upLogger') up_logger.setLevel(logging.INFO) up_logger.addHandler(CloudLoggingHandler(cloud_logging.Client(), name="updated")) # Import tensorflow_datasets import tensorflow_datasets as tfds # Import numpy import numpy as np # Import TensorFlow import tensorflow as tf # Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.batch(BATCH_SIZE) ds_test = ds_test.batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)]) # Compile data model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5) # Logs model summary model.summary(print_fn=up_logger.info) # Print out max value to see the changes image_batch, labels_batch = next(iter(ds_train)) t_image_batch, t_labels_batch = next(iter(ds_test)) up_logger.info("training images max " + str(np.max(image_batch[0]))) up_logger.info("test images max " + str(np.max(t_image_batch[0])))

4. Drücken Sie Strg + S oder gehen Sie zu Datei > Notebook speichern, um die Änderungen zu speichern

5. Führen Sie den Code aus, indem Sie auf Ausführen klicken oder Umschalttaste + Eingabetaste drücken.

Erwartete Ausgabe für # Print out max value to see the changes

INFO:upLogger:training images max 255 INFO:upLogger:test images max 255

Nach Abschluss der Epochen sehen Sie den Unterschied bei der Accuracy ohne Normalisierung.

Warum ändert sich Ihrer Meinung nach die Accuracy?

Auf Stack Overflow finden Sie eine hervorragende Antwort auf diese Frage.

Klicken Sie auf Fortschritt prüfen. Übung 3

Übung 4

Was geschieht, wenn Sie die Ebene Flatten() entfernen und was ist die Ursache für die Veränderung?

Probieren Sie es aus.

1. Entfernen Sie im Abschnitt # Define the model den Code tf.keras.layers.Flatten():

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Speichern Sie die Änderungen und führen Sie die Zelle in updated_model.ipynb aus.

Es wird ein Fehler bezüglich der Datenform ausgegeben. Dies ist zu erwarten.

Die Details des Fehlers erscheinen im Moment möglicherweise noch unklar, aber er bestätigt die Faustregel, dass die erste Netzwerkebene dieselbe Form wie die Daten haben sollte. Aktuell haben die Eingabebilder die Form 28 × 28, aber 28 Ebenen mit 28 Neuronen sind nicht möglich. Daher ist es sinnvoll, die 28,28 zu 784 × 1 zu vereinfachen.

Anstatt den ganzen Code selbst zu schreiben, können Sie am Anfang die Ebene Flatten() einfügen. Wenn die Arrays später in das Modell geladen werden, werden sie automatisch vereinfacht.

Übung 5

Sehen Sie sich die letzte (Ausgabe-)Ebene an. Warum umfasst sie zehn Neuronen? Was geschieht bei einer anderen Anzahl?

Finden Sie es heraus, indem Sie das Netzwerk mit fünf Neuronen trainieren.

1. Ersetzen Sie den Abschnitt # Define the model durch den folgenden Code, um die Änderungen in der vorherigen Übung rückgängig zu machen:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Ändern Sie die Anzahl der Neuronen in der letzten Ebene von zehn auf fünf:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(5, activation=tf.nn.softmax)])

3. Speichern Sie die Änderungen und führen Sie die Zelle in updated_model.ipynb aus.

Ergebnis: Ein Fehler wird ausgegeben, sobald das Modell einen unerwarteten Wert findet.

Eine weitere Faustregel lautet: Die Anzahl der Neuronen in der letzten Ebene sollte der Anzahl der Klassen entsprechen, für die Sie Daten klassifizieren. In diesem Fall sind dies die Ziffern 0–9. Das sind insgesamt zehn, daher sollte die letzte Ebene zehn Neuronen umfassen.

Glückwunsch!

Glückwunsch! Sie haben gelernt, ein Tensorflow-Modell zu entwerfen, zu kompilieren, zu trainieren und zu evaluieren. Außerdem haben Sie gelernt, wie Sie Modelle speichern und laden sowie eigene Callbacks schreiben, um das Verhalten während des Trainings anzupassen. Zum Schluss haben Sie eine Reihe von Übungen absolviert, um mit den verschiedenen Netzwerkebenen zu experimentieren.

Weitere Informationen

• Intensivkurs zum maschinellen Lernen
• Seite zum Testen der Möglichkeiten von maschinellem Sehen
• Vertex AI-Dokumentation
• Experimente mit der KI von Google
• Informationen zu TensorFlow

Google Cloud-Schulungen und -Zertifizierungen

In unseren Schulungen erfahren Sie alles zum optimalen Einsatz unserer Google Cloud-Technologien und können sich entsprechend zertifizieren lassen. Unsere Kurse vermitteln technische Fähigkeiten und Best Practices, damit Sie möglichst schnell mit Google Cloud loslegen und Ihr Wissen fortlaufend erweitern können. Wir bieten On-Demand-, Präsenz- und virtuelle Schulungen für Anfänger wie Fortgeschrittene an, die Sie individuell in Ihrem eigenen Zeitplan absolvieren können. Mit unseren Zertifizierungen weisen Sie nach, dass Sie Experte im Bereich Google Cloud-Technologien sind.

Anleitung zuletzt am 12. September 2024 aktualisiert

Lab zuletzt am 12. September 2024 getestet

© 2025 Google LLC. Alle Rechte vorbehalten. Google und das Google-Logo sind Marken von Google LLC. Alle anderen Unternehmens- und Produktnamen können Marken der jeweils mit ihnen verbundenen Unternehmen sein.