What is TensorFlow?
The shortest definition would be, TensorFlow is a general-purpose library for graph-based computation.
But there is a variety of other ways to define TensorFlow, for example, Rodolfo Bonnin in his book – Building Machine Learning Projects with TensorFlow brings up definition like this:
“TensorFlow is an open source software library for numerical computation using data flow graphs. Nodes in the graph represent mathematical operations, while the graph edges represent the multidimensional data arrays (tensors) passed between them.”
To quote the TensorFlow website, TensorFlow is an “open source software library for numerical computation using data flow graphs”. Name TensorFlow derives from the operations which neural networks perform on multidimensional data arrays, often referred to as ‘tensors’. It is using data flow graphs and is capable of building and training variety of different machine learning algorithms including deep neural networks, at the same time, it is general enough to be applicable in a wide variety of other domains as well. Flexible architecture allows deploying computation to one or more CPUs or GPU in a desktop, server, or mobile device with a single API.
TensorFlow is Google Brain’s second generation machine learning system, released as open source software in 2015. TensorFlow is available on 64-bit Linux, macOS, and mobile computing platforms including Android and iOS. TensorFlow provides a Python API, as well as C++, Haskell, Java and Go APIs. Google’s machine learning framework became lately ‘hottest’ in data science world, it is particularly useful for building deep learning systems for predictive models involving natural language processing, audio, and images.
What is ‘Graph’ or ‘Data Flow Graph’? What is TensorFlow Session?
Trying to define what TensorFlow is, it is hard to avoid using word ‘graph’, or ‘data flow graph’, so what is that? The shortest definition would be, TensorFlow Graph is a description of computations. Deep learning (neural networks with many layers) uses mostly very simple mathematical operations – just many of them, on high dimensional data structures(tensors). Neural networks can have thousands or even millions of weights. Computing them, by interpreting every step (Python) would take forever.
That’s why we create a graph made up of defined tensors and mathematical operations and even initial values for variables. Only after we’ve created this ‘recipe’ we can pass it to what TensorFlow calls a session. To compute anything, a graph must be launched in a Session. The session runs the graph using very efficient and optimized code. Not only that, but many of the operations, such as matrix multiplication, are ones that can be parallelised by supported GPU (Graphics Processing Unit) and the session will do that for you. Also, TensorFlow is built to be able to distribute the processing across multiple machines and/or GPUs.
TensorFlow programs are usually divided into a construction phase, that assembles a graph, and an execution phase that uses a session to execute operations in the graph. To do machine learning in TensorFlow, you want to create tensors, adding operations (that output other tensors), and then executing the computation (running the computational graph). In particular, it’s important to realize that when you add an operation on tensors, it doesn’t execute immediately. TensorFlow waits for you to define all the operations you want to perform and then optimizes the computation graph, ‘deciding’ how to execute the computation, before generating the data. Because of this, tensors in TensorFlow are not so much holding the data as a placeholder for holding the data, waiting for the data to arrive when a computation is executed.
NEURAL NETWORKS – basics.
Before we move on to create our first model in TensorFlow, we’ll need to get the basics right, talk a bit about the structure of a simple neural network.
A simple neural network has some input units where the input goes. It also has hidden units, so-called because from a user’s perspective they’re hidden. And there are output units, from which we get the results. Off to the side are also bias units, which are there to help control the values emitted from the hidden and output units. Connecting all of these units are a bunch of weights, which are just numbers, each of which is associated with two units. The way we train neural network is to assign values to all those weights. That’s what training a neural network does, find suitable values for those weights. One step in “running” the neural network is to multiply the value of each weight by the value of its input unit, and then to store the result in the associated unit.
There is plenty of resources available online to get more background on the neural networks architectures, few examples below:
- neuralnetworksanddeeplearning.com – by Michael Nielsen
- deeplearningbook.org – by Ian Goodfellow, Yoshua Bengio, Aaron Courville.
- Machine Learning – by AndrewNg via Coursera
- Neural Networks for Machine Learning – by Geoffrey Hinton via Coursera
- Robotics: Vision Intelligence and Machine Learning – edx – University of Pennsylvania
- Make Your Own Neural Network by
- Neural Networks for Complete Beginners: Introduction for Neural Network Programming
- Introduction to the Math of Neural Networks
- Neural Network Programming with Python: Create your own neural network!
- Neural Networks: A Comprehensive Foundation (2nd Edition)
Deep learning uses very simple mathematical operations, it would be recommended to get/refresh at least basics of them. I recommend starting from one of the following:
- Vector Algebra- simpleNeasyBook by WAGmob
- Vector Calculus, Linear Algebra and Differential Forms: A Unified Approach by Barbara Burke Hubbard, John H. Hubbard
- deeplearningbook.org – by Ian Goodfellow, Yoshua Bengio, Aaron Courville.
- Linear algebra cheat sheet for deep learning by Brendan Fortuner
- Data Science Math Skills – by Coursera
- Linear Algebra – Foundations to Frontiers – by edx
It would be advised to have basics Python programming before moving forward, few available resources:
- A Byte of Python by Swaroop C H
- Python for Everybody – Prof.Charles Severance
- Python Programming by Wikibooks
- Think Python: How would you Think Like a Computer Scientist by Allen Downey
- Dive Into Python 3 by Mark Pilgrim
- Python Machine Learning
- Python Programming: An Introduction to Computer Science
- Introduction to Data Science in Python – by Coursera
- Python for Data Science by edx
Let’s do it… TensorFlow first example code.
To keep things simple let’s start with ‘Halo World’ example.
import tensorflow as tf
Declaring constants/variables, TensorFlow constants can be declared using the tf.constant function, and variables with the tf.Variable function. The first element in both is the value to be assigned the constant/variable when it is initialised. TensorFlow will infer the type of the constant/variable initialised value, but it can also be set explicitly using the optional dtype argument. It’s important to note that, as the Python code runs through these commands, the variables haven’t actually been declared as they would have been if you just had a standard Python declaration.
x = tf.constant(2.0) y = tf.Variable(3.0)
Lets make our code compute something, simple multiplication.
z = y * x
Now comes the time when we would like to see the outcome, except nothing, has been computed yet… welcome to the TensorFlow. To make use of TensorFlow variables and perform calculations, Session must be created and all variables must be initialized. We can do it using the following statements.
sess = tf.Session() init = tf.global_variables_initializer() sess.run(init)
We have Session and even all constants/variables in place. Let’s see the outcome.
print("z = y * x = ", sess.run(z))
If you see something like this:
‘z = y * x = 6.0’
Congratulations, you have just coded you first TensorFlow ‘model’.
Below whole code in one piece:
import tensorflow as tf x = tf.constant(2.0) y = tf.Variable(3.0) z = y * x sess = tf.Session() init = tf.global_variables_initializer() sess.run(init) print("z = y * x = ", sess.run(z))
This tutorial, of course, will not end up like this and will be continued soon… in next part, we will code our first neural network in TensorFlow.
Was the above useful? Please share with others on social media.
Recommended reading list:
|Hands-On Machine Learning with Scikit-Learn and TensorFlow: Concepts, Tools, and Techniques to Build Intelligent Systems
Through a series of recent breakthroughs, deep learning has boosted the entire field of machine learning. Now, even programmers who know close to nothing about this technology can use simple, efficient tools to implement programs capable of learning from data. This practical book shows you how.
By using concrete examples, minimal theory, and two production-ready Python frameworks—scikit-learn and TensorFlow—author Aurélien Géron helps you gain an intuitive understanding of the concepts and tools for building intelligent systems. You’ll learn a range of techniques, starting with simple linear regression and progressing to deep neural networks. With exercises in each chapter to help you apply what you’ve learned, all you need is programming experience to get started.
Explore the machine learning landscape, particularly neural nets
Use scikit-learn to track an example machine-learning project end-to-end
Explore several training models, including support vector machines, decision trees, random forests, and ensemble methods
Use the TensorFlow library to build and train neural nets
Dive into neural net architectures, including convolutional nets, recurrent nets, and deep reinforcement learning
Learn techniques for training and scaling deep neural nets
Apply practical code examples without acquiring excessive machine learning theory or algorithm details
|TensorFlow Machine Learning Cookbook
This guide starts with the fundamentals of the TensorFlow library which includes variables, matrices, and various data sources. Moving ahead, you will get hands-on experience with Linear Regression techniques with TensorFlow. The next chapters cover important high-level concepts such as neural networks, CNN, RNN, and NLP.
Once you are familiar and comfortable with the TensorFlow ecosystem, the last chapter will show you how to take it to production.
What you will learn
Become familiar with the basics of the TensorFlow machine learning library
Get to know Linear Regression techniques with TensorFlow
Learn SVMs with hands-on recipes
Implement neural networks and improve predictions
Apply NLP and sentiment analysis to your data
Master CNN and RNN through practical recipes
Take TensorFlow into production
|Learning TensorFlow: A Guide to Building Deep Learning Systems
TensorFlow is currently the leading open-source software for deep learning, used by a rapidly growing number of practitioners working on computer vision, Natural Language Processing (NLP), speech recognition, and general predictive analytics. This book is an end-to-end guide to TensorFlow designed for data scientists, engineers, students and researchers.
With this book you will learn how to:
Get up and running with TensorFlow, rapidly and painlessly
Build and train popular deep learning models for computer vision and NLP
Apply your advanced understanding of the TensorFlow framework to build and adapt models for your specific needs
Train models at scale, and deploy TensorFlow in a production setting
|TensorFlow for Machine Intelligence: A Hands-On Introduction to Learning Algorithms
TensorFlow, a popular library for machine learning, embraces the innovation and community-engagement of open source, but has the support, guidance, and stability of a large corporation. Because of its multitude of strengths, TensorFlow is appropriate for individuals and businesses ranging from startups to companies as large as, well, Google. TensorFlow is currently being used for natural language processing, artificial intelligence, computer vision, and predictive analytics. TensorFlow, open sourced to the public by Google in November 2015, was made to be flexible, efficient, extensible, and portable. Computers of any shape and size can run it, from smartphones all the way up to huge computing clusters. This book is for anyone who knows a little machine learning (or not) and who has heard about TensorFlow, but found the documentation too daunting to approach. It introduces the TensorFlow framework and the underlying machine learning concepts that are important to harness machine intelligence. After reading this book, you should have a deep understanding of the core TensorFlow API.
|Machine Learning with TensorFlow
Being able to make near-real-time decisions is becoming increasingly crucial. To succeed, we need machine learning systems that can turn massive amounts of data into valuable insights. But when you're just starting out in the data science field, how do you get started creating machine learning applications? The answer is TensorFlow, a new open source machine learning library from Google. The TensorFlow library can take your high level designs and turn them into the low level mathematical operations required by machine learning algorithms.
Machine Learning with TensorFlow teaches readers about machine learning algorithms and how to implement solutions with TensorFlow. It starts with an overview of machine learning concepts and moves on to the essentials needed to begin using TensorFlow. Each chapter zooms into a prominent example of machine learning. Readers can cover them all to master the basics or skip around to cater to their needs. By the end of this book, readers will be able to solve classification, clustering, regression, and prediction problems in the real world.