#### Overview of this book

TensorFlow is an open source software library for Machine Intelligence. The independent recipes in this book will teach you how to use TensorFlow for complex data computations and allow you to dig deeper and gain more insights into your data than ever before. With the help of this book, you will work with recipes for training models, model evaluation, sentiment analysis, regression analysis, clustering analysis, artificial neural networks, and more. You will explore RNNs, CNNs, GANs, reinforcement learning, and capsule networks, each using Google's machine learning library, TensorFlow. Through real-world examples, you will get hands-on experience with linear regression techniques with TensorFlow. Once you are familiar and comfortable with the TensorFlow ecosystem, you will be shown how to take it to production. By the end of the book, you will be proficient in the field of machine intelligence using TensorFlow. You will also have good insight into deep learning and be capable of implementing machine learning algorithms in real-world scenarios.
Preface
Free Chapter
Getting Started with TensorFlow
The TensorFlow Way
Support Vector Machines
Nearest-Neighbor Methods
Natural Language Processing
Convolutional Neural Networks
Recurrent Neural Networks
Taking TensorFlow to Production
More with TensorFlow
Other Books You May Enjoy

# Declaring variables and tensors

Tensors are the primary data structure that TensorFlow uses to operate on the computational graph. We can declare these tensors as variables and/or feed them in as placeholders. To do this, first, we must learn how to create tensors.

A tensor is a mathematical term that refers to generalized vectors or matrices. If vectors are one-dimensional and matrices are two-dimensional, a tensor is n-dimensional (where n could be 1, 2, or even larger).

When we create a tensor and declare it as a variable, TensorFlow creates several graph structures in our computation graph. It is also important to point out that just by creating a tensor, TensorFlow is not adding anything to the computational graph. TensorFlow does this only after running an operation to initialize the variables. See the next section, on variables and placeholders, for more information.

# How to do it...

Here, we will cover the main ways that we can create tensors in TensorFlow:

1. Fixed tensors:

• In the following code, we are creating a zero-filled tensor:
`zero_tsr = tf.zeros([row_dim, col_dim])`
• In the following code, we are creating a one-filled tensor:
`ones_tsr = tf.ones([row_dim, col_dim]) `
• In the following code, we are creating a constant-filled tensor:
`filled_tsr = tf.fill([row_dim, col_dim], 42) `
• In the following code, we are creating a tensor out of an existing constant:
`constant_tsr = tf.constant([1,2,3])`
Note that the tf.constant() function can be used to broadcast a value into an array, mimicking the behavior of tf.fill() by writing tf.constant(42, [row_dim, col_dim]).
1. Tensors of similar shape: We can also initialize variables based on the shape of other tensors, as follows:
```zeros_similar = tf.zeros_like(constant_tsr)
ones_similar = tf.ones_like(constant_tsr) ```
Note that since these tensors depend on prior tensors, we must initialize them in order. Attempting to initialize all the tensors all at once will result in an error. See the There's more... subsection at the end of the next section, on variables and placeholders.
1. Sequence tensors: TensorFlow allows us to specify tensors that contain defined intervals. The following functions behave very similarly to the NumPy's linspace() outputs and range() outputs. See the following function:
`linear_tsr = tf.linspace(start=0, stop=1, start=3) `

The resultant tensor has a sequence of [0.0, 0.5, 1.0]. Note that this function includes the specified stop value. See the following function for more information:

`integer_seq_tsr = tf.range(start=6, limit=15, delta=3) `

The result is the sequence [6, 9, 12]. Note that this function does not include the limit value.

1. Random tensors: The following generated random numbers are from a uniform distribution:
`randunif_tsr = tf.random_uniform([row_dim, col_dim], minval=0, maxval=1) `

Note that this random uniform distribution draws from the interval that includes the minval but not the maxval (minval <= x < maxval).

To get a tensor with random draws from a normal distribution, you can run the following code:

`randnorm_tsr = tf.random_normal([row_dim, col_dim], mean=0.0, stddev=1.0) `

There are also times where we want to generate normal random values that are assured within certain bounds. The truncated_normal() function always picks normal values within two standard deviations of the specified mean:

`runcnorm_tsr = tf.truncated_normal([row_dim, col_dim], mean=0.0, stddev=1.0) `

We might also be interested in randomizing entries of arrays. To accomplish this, there are two functions that can help us: random_shuffle() and random_crop(). The following code performs this:

```shuffled_output = tf.random_shuffle(input_tensor)
cropped_output = tf.random_crop(input_tensor, crop_size) ```

Later on in this book, we will be interested in randomly cropping images of size (height, width, 3) where there are three color spectrums. To fix a dimension in the cropped_output, you must give it the maximum size in that dimension:

`cropped_image = tf.random_crop(my_image, [height/2, width/2, 3]) `

# How it works...

Once we have decided how to create the tensors, we may also create the corresponding variables by wrapping the tensor in the Variable() function, as follows (more on this in the next section):

`my_var = tf.Variable(tf.zeros([row_dim, col_dim])) `

# There's more...

We are not limited to the built-in functions: we can convert any NumPy array into a Python list, or a constant into a tensor using the convert_to_tensor() function. Note that this function also accepts tensors as an input in case we wish to generalize a computation inside a function.