Cómo empezar a depurar TensorFlow

Tabla de contenido

  • De que se trata esto
  • La base del código de referencia
  • 1. Obtenga e imprima valores dentro de Session.run
  • 2. Utilice la operación tf.Print
  • 3. Utilice la visualización de Tensorboard para supervisar
  • a) limpiar el gráfico con nombres propios y ámbitos de nombres
  • b) Agregar tf.summaries
  • c) Agregue un tf.summary.FileWriter para crear archivos de registro
  • d) Inicie el servidor de tensorboard desde su terminal
  • 4. Usa el depurador de Tensorboard
  • 5. Usa el depurador de TensorFlow
  • Conclusión

De que se trata esto

La depuración es dos veces más difícil que escribir el código en primer lugar. Por lo tanto, si escribe el código de la manera más inteligente posible, por definición, no es lo suficientemente inteligente como para depurarlo. - BRIAN W. KERNIGHAN

La depuración en general puede ser una tarea tediosa y desafiante. Sin embargo, debe sentirse cómodo revisando el código escrito e identificando problemas. Normalmente, existen muchas guías y el proceso de depuración suele estar bien documentado para muchos lenguajes y marcos.

Sin embargo, cuando se trata de TensorFlow, surgen algunos desafíos nuevos debido a la forma en que funciona.

Como dice la documentación oficial:

Un programa de TensorFlow Core consta de dos secciones discretas:

  1. Construyendo el gráfico computacional (un tf.Graph).
  2. Ejecutando el gráfico computacional (usando un tf.Session).

El cálculo real se realiza con session.run(), lo que significa que necesitamos encontrar una manera de inspeccionar los valores dentro de esta función.

La base del código de referencia

Como referencia, proporcionaré a mi repositorio de Github el código correspondiente aquí.

Usaremos una red neuronal básica para clasificar los dígitos escritos a mano del conjunto de datos MNIST, usando:

  • tf.nn.softmax_cross_entropy_with_logits_v2 como la operación de clasificación TF para definir la pérdida
  • tf.train.GradientDescentOptimizer para minimizar la pérdida

La ejecución de esta pequeña red neuronal muestra que ya puede alcanzar una precisión de ~ 92%:

El proceso de depuración

Ahora para la depuración, hay básicamente 5 formas (pragmáticas) de lograrlo.

Como nota al margen: a menudo es útil afirmar formas para asegurarse de que todo funcione en conjunto según lo previsto.

1. Obtenga e imprima valores dentro de Session.run

Esta es probablemente la forma más rápida y sencilla de obtener la información que necesita.

  • facil y rapido
  • cualquier evaluación se puede obtener de todas partes
  • es necesario mantener la referencia al tensor, lo cual es malo en modelos complejos

En esencia, ejecuta la sesión en una declaración impresa y la alimenta al diccionario, así: print( f"The bias parameter is: {sess.run(b, feed_dict={x: mnist.test.images, y_: mnist.test.labels})}" )

Si el código se vuelve más complejo, se podría usar la ejecución de ejecución parcial de una sesión. Pero dado que esta es una característica experimental, no la implementaré para demostración.

Además, no olvide el .eval()método para evaluar tensores específicamente.

Vea el código completo aquí en Github.

2. Utilice la operación tf.Print

El método tf.Print es útil durante la evaluación en tiempo de ejecución cuando no queremos obtener explícitamente el código con session.run (). Es una operación de identidad que imprime datos al evaluar.

  • nos permite ver el desarrollo de valores durante la evaluación
  • Tiene una configuración limitada y, por lo tanto, puede obstruir fácilmente el terminal.

Yufeng G creó un video y un artículo fantástico sobre cómo usar la declaración tf.Print. Y, como señala, es vital estructurar el nodo de impresión de la forma en que se utiliza más. Como él dice:

It is vitally important that you actually use this returned node, because if you don’t, it will be dangling.

In my code, I added a print statement that fetches the values within the session to illustrate how both methods perform differently in execution.

With runtime evaluation comes the possibility of runtime assertion with tf.Assert .

See the full code here.

3. Use Tensorboard visualization for monitoring

Before diving into this debugging method, be aware that there is the Tensorboard and the Tensorboard debugger!

The TF website offers a great tutorial for implementing and using the board.

A key for the usage is the serializing of the data. TensorFlow provides the summary operations, which allow you to export condensed information about the model. They are like anchors telling the visualization board what to plot.

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