Sådan kommer du i gang med fejlfinding af TensorFlow

Indholdsfortegnelse

  • Hvad det drejer sig om
  • Referencekodebasen
  • 1. Hent og udskriv værdier inden for Session.run
  • 2. Brug funktionen tf.Print
  • 3. Brug Tensorboard-visualisering til overvågning
  • a) rens grafen med egennavne og navneomfang
  • b) Tilføj tf.sammendrag
  • c) Tilføj en tf.summary.FileWriter for at oprette logfiler
  • d) Start tensorboardserveren fra din terminal
  • 4. Brug Tensorboard-fejlfindingsprogrammet
  • 5. Brug TensorFlow-fejlfindingsprogrammet
  • Konklusion

Hvad det drejer sig om

Fejlfinding er dobbelt så hårdt som at skrive koden i første omgang. Derfor, hvis du skriver koden så klogt som muligt, er du pr. Definition ikke smart nok til at debugge den. - BRIAN W. KERNIGHAN

Fejlfinding generelt kan være en kedelig og udfordrende opgave. Ikke desto mindre skal du være fortrolig med at gennemgå den skrevne kode og identificere problemer. Normalt er der mange guider, og fejlfindingsprocessen er ofte veldokumenteret for mange sprog og rammer.

Når det kommer til TensorFlow, opstår der dog nogle nye udfordringer på grund af den måde, det fungerer på.

Som den officielle dokumentation siger:

Et TensorFlow Core-program består af to diskrete sektioner:

  1. Opbygning af beregningsgrafen (en tf.graf).
  2. Kørsel af beregningsgrafen (ved hjælp af en tf.Session).

Den aktuelle beregning udføres med session.run(), hvilket betyder, at vi skal finde en måde at inspicere værdier inde i denne funktion.

Referencekodebasen

Som reference vil jeg give mit Github-arkiv den tilsvarende kode her.

Vi bruger et grundlæggende neuralt netværk til at klassificere håndskrevne cifre fra MNIST-datasættet ved hjælp af:

  • tf.nn.softmax_cross_entropy_with_logits_v2 som TF-klassificeringsoperation til at definere tabet
  • tf.train.GradientDescentOptimizer for at minimere tabet

At køre dette lille neurale netværk viser, at det allerede kan opnå en nøjagtighed på ~ 92%:

Processen med fejlretning

Nu til fejlfinding er der dybest set 5 (pragmatiske) måder at opnå dette på.

Som en sidebemærkning: Det er ofte nyttigt at hævde former for at sikre, at alt fungerer sammen som beregnet.

1. Hent og udskriv værdier inden for Session.run

Dette er sandsynligvis den hurtigste og nemmeste måde at få de oplysninger, du har brug for.

  • let og hurtigt
  • enhver evaluering kan hentes overalt
  • det er nødvendigt at holde henvisningen til tensoren, hvilket er dårligt i komplekse modeller

I det væsentlige kører du sessionen i en udskriftserklæring og føder den til ordbogen, sådan: print( f"The bias parameter is: {sess.run(b, feed_dict={x: mnist.test.images, y_: mnist.test.labels})}" )

Hvis koden bliver mere kompleks, kan delvis_run-udførelsen af ​​en session bruges. Men da dette er en eksperimentel funktion, vil jeg ikke implementere dette til demonstration.

Derudover skal du ikke glemme .eval()metoden til evaluering af tensorer specifikt.

Se den fulde kode her på Github.

2. Brug funktionen tf.Print

Metoden tf.Print er praktisk under evaluering af kørselstiden, når vi ikke eksplicit vil hente koden med session.run (). Det er en identitetsop, der udskriver data, når de evalueres.

  • det giver os mulighed for at se udviklingen af ​​værdier under evalueringen
  • den har begrænset konfiguration og kan derfor let tilstoppe terminalen

Yufeng G oprettede en fantastisk video og artikel om, hvordan man bruger tf.Print-erklæringen. Og som han påpeger, er det vigtigt at strukturere printknudepunktet, som det bruges yderligere. Som han siger:

Det er meget vigtigt, at du rent faktisk bruger denne returnerede node, for hvis du ikke gør det, hænger den.

I min kode tilføjede jeg en udskrivningserklæring, der henter værdierne i sessionen for at illustrere, hvordan begge metoder fungerer forskelligt i udførelsen.

Med runtime-evaluering følger muligheden for runtime-påstand med tf.Assert.

Se den fulde kode her.

3. Brug Tensorboard-visualisering til overvågning

Inden du dykker ind i denne fejlretningsmetode, skal du være opmærksom på, at der er Tensorboard og Tensorboard debugger!

TF-webstedet tilbyder en god tutorial til implementering og brug af tavlen.

En nøgle til brugen er serialisering af dataene. TensorFlow indeholder de opsummerende handlinger, der giver dig mulighed for at eksportere kondenseret information om modellen. De er som ankre, der fortæller visualiseringstavlen, hvad de skal plotte.

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
  • organisere dine moduler og kode

Jeg er virkelig begejstret for alle de funktioner, som TensorFlow har at tilbyde for folk, der bygger maskinlæringssystemer. De gør et godt stykke arbejde! Ser frem til yderligere udvikling! :)

Tak, fordi du læste min artikel! Du er velkommen til at efterlade feedback!

Daniel er en LL.M. studerende i forretningsret, arbejder som softwareingeniør og arrangør af teknologirelaterede begivenheder i Wien. Hans nuværende personlige læringsindsats fokuserer på maskinlæring.

Opret forbindelse:

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