Like it! share it!

As the hype around deep learning gains momentum, many frameworks and libraries emerge around it. I get the chance to use some of them in practice and want to share my opinion and observations on what works well and what you should be aware of while working with these frameworks. One step at a time, let’s start with TensorFlow.

TensorFlow is one (and often referred to as the best) of many frameworks that are used when working with neural networks. It is Google’s open-source library for numerical computation, which also offers a set of tools for designing, training and fine-tuning neural networks.

At NeuroSYS we used it for problems concerning computer vision like image classification or generating artificial images, as in the case of creating a real-time object detection or a bacterial classification system (you can learn more about this project at its early stage here).

But enough of broad descriptions, let’s jump straight to the point.

TensorFlow Pros and Cons


#1 Great data vizualization tool – TensorBoard

TensorBoard is a suite of visualization tools in the TensorFlow library that helps to understand, debug, and optimize neural networks easier. It lets you present neural network graphs, input, output, training progress and any additional information in a clean readable way using only a few lines of code.

TensorBoard graph visualization

Here is how you can easily visualize data in TensorBoard:

# define from which variables generate summary from
loss_summary = tf.summary.scalar('loss_1', loss1)
image_summary = tf.summary.image('generated_image', result)
# merge whole summary into one instruction
summary = tf.summary.merge([loss_summary, image_summary])

# define summary writer
summary_writer = tf.summary.FileWriter('path/to/summary/',
# run summary along computation
result, summary_values = tf.Session().run([network_output, summary],
                                          feed_dict={: input_data})
#write summary to disk and view it in TensorBoard

#2 Easy production-ready model sharing

With TensorFlow one can easily share a trained model. This can sound like a must-have feature, but it’s still not a standard across different frameworks.

Many frameworks require you to provide a full code of a model in order to load its weights into. TensorFlow, on the other hand, requires only a checkpoint file and the knowledge of layers names you need for inference (the input layer is the most important here because without it we cannot run a computation graph).

This feature leads us to pro #3, as it makes the TensorFlow model useful for a broad spectrum of applications. It allows you to implement the same model (without rewriting or recompiling it) in various projects no matter what language they are written in.

It’s still not a one-liner, but at least you don’t need to define the whole model:

# imported graph to be used as default later
imported_graph = tf.Graph()
with imported_graph.as_default():
    # read graph definition from file
    graph_def = tf.GraphDef()
    with tf.gfile.GFile('path/to/model', 'rb') as model:
        # parse it
    # and import to TensorFlow
    tf.import_graph_def(graph_def, name="imported_model")

with imported_graph.as_default():
    output = tf.Session().run("output:0", feed_dict={"input:0": our_input})

#3 Multiple language support

TensorFlow is designed to support multiple client languages. It officially supports Python, C++, JavaScript, Go, Java and Swift. Although only Python, as the most commonly used one, supports all available features.

Due to high popularity, TensorFlow community created bindings to use the framework in other languages, such as C# (which we have used and I can say that was pretty good) and Ruby.

This ensures portability and allows developers to use machine learning models for desktop, mobile and even web applications.


#1 Too cluttered code

This is something that TensorFlow developers are working on, and already announced to prevent in 2.0 release. Sadly, the current state of the framework is inconsistent:

Which one to use?

  • tf.nn.conv2d
  • tf.nn.convolution
  • tf.layers.conv2d
  • tf.layers.Conv2d
  • tf.contrib.layers.conv2d
  • tf.contrib.layers.convolution2d

Even typing “tf conv2d” in google leads to 3 of these options making it really frustrating when you want to just find out which operation to use.

#2 Need for extra code

As you can see in examples above, the amount of code needed for adding functionality is not that big. Nevertheless, naming conventions may be inconsistent, and the complexity of modules can be overwhelming.

Every computation needs to be called from a session handler. This creates a situation that using TensorFlow is like using a language within another language. One can forget about writing a clean pythonic code when even something as simple as a for-loop needs to be called using a TensorFlow equivalent.

Sometimes the documentation even “forgets” to tell you that you need to include additional instructions in your code to make some things work. This happened to me when I was trying to write my own data loader using the TensorFlow pipeline and provide multiple workers to parallelize computation.

However, what was not included in the documentation, is that you need to manually launch these workers. Without this part, the whole script just halted waiting for workers to provide data. With no error or warning, it just stops and waits for data from workers which were never launched.

This is an example of how those modules aren’t always seamlessly connected with each other, which leads to the lack of communication between them, and eventually, situations like the one described above.

#3 Frequent releases

For someone, this might sound like an advantage. But in reality, new releases every 1-2 months are better to avoid in the production environment, especially when they tend to break backward compatibility.

We find it especially harmful for using bindings in different languages like C# TensorSharp. My team once encountered a problem after new arguments were introduced in one of the commonly used function, which broke compatibility with TensorSharp. The easiest solution we found was to use the older version of TensorFlow to re-export the whole model.

We understand that some changes in the rapidly developed framework are inevitable, but perhaps the community would benefit more if releases were less frequent, but more attention was paid to the consistency of the framework.

Few tips for easier work with TensorFlow

Tip #1

For better performance avoid running session for predicting only one result. Computing many operations one by one is gonna take more time than doing one session run with gathering all these operations at once. This is possible due to the TensorFlow’s ability to parallelize computation, as well as avoiding the overhead created by initializing a computation session multiple times.

Tip #2

Avoid clutter in your code! This is rather general advice, but it’s really essential when working with TensorFlow. Moving a definition of a network to another file is a good idea. This way you can easily modify it later with no need to search through large files.

To Sum Up

Despite all the cons, TensorFlow is one of the most widely used frameworks for deep learning projects, adopted by such giants as IBM, Twitter, 9GAG, Ocado… and (surprise-surprise!) Google. It stays in my top list also, although I truly wish those flaws are fixed one day (and the sooner the better).

At the same time, I think TensorFlow can be a bit overwhelming for the beginners, as it often provides too many implementation options. This might be confusing for those with no experience or basic understanding of differences among suggested implementations. If this scares you off, it’s better to opt for simpler alternatives.

So this is it. I hope you find something useful in this blog post. Stay tuned for further updates on deep learning frameworks. And don’t hesitate to drop me a line if you have any questions –


Passionate about artificial intelligence, data science and the future of tech.

Tomasz Bonus
Deep Learning Researcher at NeuroSYS
Please check your e-mail

We sent a message to your email. Confirm it and join our group of subscribers!

Join our small, but happy and loyal group of subscribers!
E-mail address
Insert your Email correctly please
I agree that NeuroSYS may collect and process my data to answer my enquiries and provide me with product and service information.
Read and accept
This site uses cookies. By continuing to navigate on this website, you accept the use of cookies.
Thank you for your application!
Let's get in touch!
We want to get to know you a little bit, but we need some help from your side. Let's start with filling gaps below.
Full name
Please provide us with your full name
Please provide us your current Email
Please provide us with your Phone number
Your LinkedIn profile
Please show us your professional social side :)
Link to your portfolio / GitHub
Please insert your Portfolio / GitHub URL correctly
Nothing to say? Maybe just a little bit? Even "Hi" will work - thanks!
CV file
Please upload your CV
Select file
Please choose one of the following
I hereby authorize the processing of my personal data included in this form for the present recruitment-related purposes by NeuroSYS Sp. z o.o. (Rybacka 7 Street, 53-565 Wrocław) (in accordance with the General Data Protection Regulation (EU) 2016/679 of 27.04.2018 on the protection of natural persons with regard to the processing of personal data and on the free movement of such data, as well as repealing Directive 95/46/EC (Data Protection Directive)). I acknowledge that submitting my personal data is voluntary, I have the right to access my data and rectify it.
Read and accept
I hereby authorize the processing of my personal data included in my job application for the needs of future recruitment processes by NeuroSYS Sp. z o.o. (Rybacka 7 Street, 53-565 Wrocław).
Read and accept
Captcha is required