Documentation

Overview

TensorFlow has APIs available in several languages both for constructing and executing a TensorFlow graph. The Python API is at present the most complete and the easiest to use, but other language APIs may be easier to integrate into projects and may offer some performance advantages in graph execution.

A word of caution: the APIs in languages other than Python are not yet covered by the API stability promises.

Python
Javascript
C++
Java
Go
Swift (Early release)

The community is encouraged to develop and maintain support for other languages with the approach recommended by the TensorFlow maintainers. For example, see the bindings for:

C#: TensorFlowSharp and TensorFlow.NET,
Haskell,
Julia,
MATLAB,
R,
Ruby,
Rust,
Scala.

TensorFlow

pip install tensorflow

TensorFlow 2.0

There are multiple changes in TensorFlow 2.0 to make TensorFlow users more productive. TensorFlow 2.0 removes redundant APIs, makes APIs more consistent (Unified RNNs, Unified Optimizers), and better integrates with the Python runtime with Eager execution.

Many RFCs have explained the changes that have gone into making TensorFlow 2.0. This guide presents a vision for what development in TensorFlow 2.0 should look like. It's assumed you have some familiarity with TensorFlow 1.x.

Set Up and Basic Usage

import os 



                import tensorflow as tf 


                
                import cProfile

In Tensorflow 2.0, eager execution is enabled by default.

tf.executing_eagerly()

Now you can run TensorFlow operations and the results will return immediately:

x = [[2.]] 

                    m = tf.matmul(x, x) 

                    print("hello, {}".format(m))

Tensors

import tensorflow as tf

Tensors are multi-dimensional arrays with a uniform type (called a dtype). You can see all supported dtypes at tf.dtypes.DType.

All tensors are immutable like Python numbers and strings: you can never update the contents of a tensor, only create a new one.

What are graphs?

Graphs are data structures that contain a set of tf.Operation objects, which represent units of computation; and tf.Tensor objects, which represent the units of data that flow between operations. They are defined in a tf.Graph context. Since these graphs are data structures, they can be saved, run, and restored all without the original Python code.

The benefits of graphs

With a graph, you have a great deal of flexibility. You can use your TensorFlow graph in environments that don't have a Python interpreter, like mobile applications, embedded devices, and backend servers. TensorFlow uses graphs as the format for saved models when it exports them from Python.

Graphs are also easily optimized, allowing the compiler to do transformations like:

Statically infer the value of tensors by folding constant nodes in your computation ("constant folding").
Separate sub-parts of a computation that are independent and split them between threads or devices.
Simplify arithmetic operations by eliminating common subexpressions.

There is an entire optimization system, Grappler, to perform this and other speedups.

In short, graphs are extremely useful and let your TensorFlow run fast, run in parallel, and run efficiently on multiple devices.

However, you still want to define our machine learning models (or other computations) in Python for convenience, and then automatically construct graphs when you need them.

Solving machine learning problems

Solving a machine learning problem usually consists of the following steps:

Obtain training data.
Define the model.
Define a loss function.
Run through the training data, calculating loss from the ideal value
Calculate gradients for that loss and use an optimizer to adjust the variables to fit the data.
Evaluate your results.

Data

Supervised learning uses inputs (usually denoted as x) and outputs (denoted y, often called labels). The goal is to learn from paired inputs and outputs so that you can predict the value of an output from an input.

Each input of your data, in TensorFlow, is almost always represented by a tensor, and is often a vector. In supervised training, the output (or value you'd like to predict) is also a tensor.

Here is some data synthesized by adding Gaussian (Normal) noise to points along a line.

# The actual line 


                    TRUE_W = 3.0 

                    TRUE_B = 2.0 


                    
                    NUM_EXAMPLES = 1000 


                    
                    # A vector of random x values 

                    x = tf.random.normal(shape=[NUM_EXAMPLES]) 
 

                    
                    # Generate some noise 

                    noise = tf.random.normal(shape=[NUM_EXAMPLES]) 


                    
                    # Calculate y 

                    y = x * TRUE_W + TRUE_B + noise