Erste Schritte beim Debuggen von TensorFlow

Inhaltsverzeichnis

  • Worum geht es hier?
  • Die Referenzcodebasis
  • 1. Abrufen und Drucken von Werten in Session.run
  • 2. Verwenden Sie die Operation tf.Print
  • 3. Verwenden Sie zur Überwachung die Tensorboard-Visualisierung
  • a) Reinigen Sie das Diagramm mit Eigennamen und Namensbereichen
  • b) Fügen Sie tf.summaries hinzu
  • c) Fügen Sie einen tf.summary.FileWriter hinzu, um Protokolldateien zu erstellen
  • d) Starten Sie den Tensorboard-Server von Ihrem Terminal aus
  • 4. Verwenden Sie den Tensorboard-Debugger
  • 5. Verwenden Sie den TensorFlow-Debugger
  • Fazit

Worum geht es hier?

Das Debuggen ist doppelt so schwierig wie das Schreiben des Codes. Wenn Sie den Code so geschickt wie möglich schreiben, sind Sie per Definition nicht klug genug, um ihn zu debuggen. - BRIAN W. KERNIGHAN

Das Debuggen im Allgemeinen kann eine mühsame und herausfordernde Aufgabe sein. Trotzdem müssen Sie den geschriebenen Code durchgehen und Probleme identifizieren können. Normalerweise gibt es viele Anleitungen, und der Debugging-Prozess ist für viele Sprachen und Frameworks häufig gut dokumentiert.

Bei TensorFlow ergeben sich jedoch aufgrund der Funktionsweise einige neue Herausforderungen.

Wie die offizielle Dokumentation besagt:

Ein TensorFlow Core-Programm besteht aus zwei einzelnen Abschnitten:

  1. Erstellen des Berechnungsgraphen (ein tf.Graph).
  2. Ausführen des Berechnungsgraphen (unter Verwendung einer tf.Session).

Die eigentliche Berechnung erfolgt mit session.run(), was bedeutet, dass wir einen Weg finden müssen, um Werte innerhalb dieser Funktion zu überprüfen.

Die Referenzcodebasis

Als Referenz werde ich meinem Github-Repository hier den entsprechenden Code zur Verfügung stellen.

Wir werden ein grundlegendes neuronales Netzwerk verwenden, um handgeschriebene Ziffern aus dem MNIST-Datensatz zu klassifizieren.

  • tf.nn.softmax_cross_entropy_with_logits_v2 als TF-Klassifizierungsoperation zum Definieren des Verlusts
  • tf.train.GradientDescentOptimizer zur Minimierung des Verlustes

Das Ausführen dieses kleinen neuronalen Netzwerks zeigt, dass es bereits eine Genauigkeit von ~ 92% erreichen kann:

Der Prozess des Debuggens

Zum Debuggen gibt es grundsätzlich 5 (pragmatische) Möglichkeiten, dies zu erreichen.

Als Randnotiz: Es ist oft nützlich, Formen zu behaupten, um sicherzustellen, dass alles wie beabsichtigt zusammenarbeitet.

1. Abrufen und Drucken von Werten in Session.run

Dies ist wahrscheinlich der schnellste und einfachste Weg, um die benötigten Informationen zu erhalten.

  • einfach und schnell
  • Jede Bewertung kann von überall abgerufen werden
  • Es ist notwendig, den Verweis auf den Tensor zu halten, was bei komplexen Modellen schlecht ist

Im Wesentlichen führen Sie die Sitzung in einer print-Anweisung aus und geben sie wie folgt in das Wörterbuch ein: print( f"The bias parameter is: {sess.run(b, feed_dict={x: mnist.test.images, y_: mnist.test.labels})}" )

Wenn der Code komplexer wird, kann die partielle Ausführung einer Sitzung verwendet werden. Da dies jedoch eine experimentelle Funktion ist, werde ich dies nicht zur Demonstration implementieren.

Vergessen Sie außerdem nicht die .eval()Methode zur spezifischen Bewertung von Tensoren.

Den vollständigen Code finden Sie hier auf Github.

2. Verwenden Sie die Operation tf.Print

Die tf.Print-Methode ist während der Laufzeitauswertung nützlich, wenn der Code nicht explizit mit session.run () abgerufen werden soll. Es ist eine Identitätsoperation, die bei der Auswertung Daten druckt.

  • es ermöglicht uns, die Entwicklung von Werten während der Bewertung zu sehen
  • Es ist nur begrenzt konfiguriert und kann daher das Terminal leicht verstopfen

Yufeng G hat ein fantastisches Video und einen Artikel über die Verwendung der Anweisung tf.Print erstellt. Und wie er betont, ist es wichtig, den Druckknoten so zu strukturieren, wie er weiter verwendet wird. Wie er sagt:

Es ist äußerst wichtig, dass Sie diesen zurückgegebenen Knoten tatsächlich verwenden, da er sonst baumelt, wenn Sie dies nicht tun.

In meinem Code habe ich eine print-Anweisung hinzugefügt, die die Werte innerhalb der Sitzung abruft, um zu veranschaulichen, wie beide Methoden bei der Ausführung unterschiedlich funktionieren.

Mit der Laufzeitauswertung kommt die Möglichkeit der Laufzeitzusicherung mit tf.Assert.

Den vollständigen Code finden Sie hier.

3. Verwenden Sie zur Überwachung die Tensorboard-Visualisierung

Beachten Sie vor dem Eintauchen in diese Debugging-Methode, dass es den Tensorboard- und den Tensorboard-Debugger gibt!

Die TF-Website bietet ein großartiges Tutorial für die Implementierung und Verwendung des Boards.

Ein Schlüssel für die Verwendung ist die Serialisierung der Daten. TensorFlow bietet die Zusammenfassungsoperationen, mit denen Sie komprimierte Informationen über das Modell exportieren können. Sie sind wie Anker, die der Visualisierungstafel sagen, was zu zeichnen ist.

a) Clean the graph with proper names and name scopes

First we need to organize all the variables and operations with the scope methods that TF provides.

with tf.name_scope("variables_scope"): x = tf.placeholder(tf.float32, shape=[None, 784], name="x_placeholder") y_ = tf.placeholder(tf.float32, shape=[None, 10], name="y_placeholder")

b) Add tf.summaries

For example:

with tf.name_scope("weights_scope"): W = tf.Variable(tf.zeros([784, 10]), name="weights_variable") tf.summary.histogram("weight_histogram", W)

c) Add a tf.summary.FileWriter to create log files

Tip: Make sure to create sub folders for each log to avoid accumulation of graphs.

d) Start the tensorboard server from your terminal

For example: tensorboard --logdir=./tfb_logs/ --port=8090 --host=127.0.0.1

Navigating to the tensorboard server (in this case //127.0.0.1:8090) shows the following:

Now the full power and use of tensorboard becomes clear. It allows you very easily to spot errors in your machine learning model. My code example is a very simple one. Imagine a model with multiple layers and more variables and operations!

See full code here on Github.

4. Use the Tensorboard debugger

As the Tensorboard Github repository states:

This dashboard is in its alpha release. Some features are not yet fully functional.

However, it can still be used and provides cool debugging features. Please check out the Github repository to get an adequate overview. Also, see their video to get a deeper understanding. They have done a great job.

To accomplish this, there are 3 things to add to our previous example:

  1. Import from tensorflow.python import debug as tf_debug
  2. Add your session with tf_debug.TensorBoardDebugWrapsperSession
  3. Add to your tensorboard server the debugger_port

Now you have the option to debug the whole visualized model like with any other debugger, but with a beautiful map. You are able to select certain nodes and inspect them, control execution with the “step” and “continue” buttons, and visualize tensors and their values.

There is much more to talk about regarding this unique feature of Tensorflow, but I will probably dedicate another article to that.

See my full code here on Github.

5. Use the TensorFlow debugger

The last method, but also very powerful, is the CLI TensorFlow debugger.

This debugger focuses on the command-line interface (CLI) of tfdbg, as opposed to the graphical user interface (GUI) of tfdbg, that is the TensorBoard Debugger Plugin.

You simply wrap the session with tf_debug.LocalCLIDebugWrapperSession(sess) and then you start the debugging with executing the file (maybe it's necessary to add the --debug flag).

It basically allows you to run and step through the execution of your model, while providing evaluation metrics.

I think the official documention could be improved, but they have also created a video which introduces the feature in a good way.

So the key features here are the commands invoke_stepper and then pressing s to step through each operation. It is the basic debugger functionality of a debugger but in the CLI. It looks like this:

See the full code here on Github.

Conclusion

As shown, there are many ways to debug a TensorFlow application. Each method has its own strengths and weaknesses. I didn’t mention the Python debugger, because it is not TensorFlow specific, but keep in mind that the simple Python debugger already provides some good insights!

There is a great presentation by Wookayin who talks about these concepts as well but also goes over some general debugging advise. That advice is:

  • name tensors properly
  • check and sanitize input
  • logging
  • assertions
  • proper use of exceptions
  • failing fast -> immediately abort if something is wrong
  • don’t repeat yourself
  • organize your modules and code

I am really excited for all the features that TensorFlow has to offer for people who are building machine learning systems. They are doing a great job! Looking forward to further developments! :)

Thanks for reading my article! Feel free to leave any feedback!

Daniel is a LL.M. student in business law, working as a software engineer and organizer of tech related events in Vienna. His current personal learning efforts focus on machine learning.

Connect on:

  • LinkedIn
  • Github
  • Medium
  • Twitter
  • Steemit
  • Hashnode