# Tensor and their Fundamentals

In the previous article, we have read in-depth about TensorFlow history, how it works, Architecture, and algorithm supported by Tensorflow. If you haven't read the article here's the link.

As the preparations for the conference gain momentum let’s move towards other exciting facets of Tensor.

In this Tensor and their fundamentals tutorial, we are going to cover the following:

- Tensorflow Installation
- Tensor Fundamentals
- What is Tensors
- Tensor Data Type
- Tensor Rank
- Tensorflow sessions
- Computation Graph
- Tensor Basic Operations (add, multiply..)
- Programming Elements in Tensorflow

## Tensorflow Installation

TensorFlow is tested and supported on almost every 64-bit system. You can use Python Package manager or use the TensorFlow docker container.

### Using Package Manager

Official packages available for Ubuntu, Windows, macOS, and the Raspberry Pi.

*Note: Please create a Python environment before installing any of the packages. You can read here the benefits of using virtualenv *

```
# Requires the latest pip
pip install --upgrade pip
# Current stable release for CPU and GPU
pip install tensorflow
# Or try the preview build (unstable)
pip install tf-nightly
```

### Using docker container

The TensorFlow Docker images are already configured to run TensorFlow. A Docker container runs in a virtual environment and is the easiest way to set up GPU support.

```
docker pull tensorflow/tensorflow:latest # Download latest stable image
docker run -it -p 8888:8888 tensorflow/tensorflow:latest-jupyter # Start Jupyter server
```

If you stuck anywhere in installation, drop a here in TensorFlow community. We are here to help anytime 😊️.

## Tensor Fundamentals

First, we’re going to take a look at the *tensor object type*. Then we’ll have a graphical understanding of TensorFlow to define computations. Finally, we’ll run the graphs with sessions, showing how to substitute intermediate values.

## What is Tensors

In TensorFlow, data isn't stored as integers, floats, or strings. These values are encapsulated in an object **called a tensor**, a fancy term of **multi-dimensional arrays**.

**In definition:** A tensor is a mathematical object represented as arrays of *higher dimensions*. These arrays of data with **different sizes** and **ranks** get fed as input to the neural network. These are the tensors.

You can have arrays or vectors, which are one-dimensional, or matrices, which are two-dimensional. But *tensor can be more than three, four, or five-dimensional*.

Let us look at an example of a **tensor of [5,4] dimensions (two-dimensional)**.

Next, you can see a **tensor of dimensions [3,3,3] (three-dimensional)**.

```
import tensorflow as tf
# You can create constants in TF to hold specific values
A = tf.constant(1234)
# B is a 1-dimensional int32 tensor
B = tf.constant([123,456,789])
# C is a 2-dimensional int32 tensor
C = tf.constant([ [123,456,789], [222,333,444] ])
```

## Tensor Data Type

In addition to shape and dimension, tensors also have a data type. It support from `int8 to float32`

as well as `Boolean and string type`

.

The following is a list of data type:

## Tensor Rank

Tensor rank is nothing but the *dimension of the tensor*. It starts with zero. Zero is a scalar that doesn't have multiple entries in it. It's a single value.

**For example:**

```
s = 10 is tensor of rank 0 or a scalar.
V = [10,11,12] is tensor of rank 1 or a vector
M = [[1,3,4], [4,5,6]] is tensor of rank 2 or a matrix
T = [[[1],[2],[3]],[[4],[5],[6]],[[7],[8],[9]]] is a tensor of rank 3 or a tensor.
```

## Tensorflow Sessions

Everything so far just specified the TensorFlow graph. We haven't yet computed anything. To do this, we need to *start a session in which the computations will take place.*

To do so, we need to create a new session `Session()`

which is the TensorFlow inbuilt function to do so.

```
sess = tf.Session()
```

TensorFlow’s API is built around the idea of a computational graph, a way of visualizing a mathematical process.

### Running a session and evaluating a tensor

The code itself creates a new session instance using `tf.Session()`

. The `sess.run()`

function then evaluates the tensor and returns the results.

Once you have a session open, `sess.run()`

will evaluate the given expression and return the result of the computation.

**Let's see by an hello world example**:

```
import tensorflow as tf
# Create TensorFlow object called hello_constant
hello_constant = tf.constant('Hello World!')
with tf.Session() as sess:
# Run the tf.constant operation in the session
output = sess.run(hello_constant)
print(output)
#Output
Hello World
```

## Computation Graph

Everything in TensorFlow is based on designing a computational graph. The graph has a *network of nodes*, with each node operating **addition, multiplication, or evaluating some multivariate equation**.

Let’s dive a bit more into a computational graph and understand how computation graphs are formed,

Consider a simple computation. Let **a, b, c** be the variables used,

```
J = 3 * ( a + bc )
```

There are 3 distinctive computational steps to arrive at the final value J, let’s list them out,

```
u = b * c
v = (a + u)
J = 3 * v
```

These are 3 computational steps which can be represented as a graph,

Here are the **advantages of organizing the computations as a graph**,

- Parallelism
- Distributed execution
- Compilation

### Tensorflow Placeholder

`tf.placeholder()`

returns a tensor that gets its value from data passed to the `tf.session.run()`

function, allowing you to set the input right before the session runs.

```
The syntax is:
tf.placeholder(dtype,shape=None,name=None )
arguments:
- `dtype`: Type of data
- `shape`: dimension of the placeholder. Optional. By default, shape of the data
- `name`: Name of the placeholder. Optional
data_placeholder_a = tf.placeholder(tf.float32, name = "data_placeholder_a")
```

Let’s revisit our **Hello world example**, but this time *let’s set the value right before the session evaluates the tensor*.

```
import tensorflow as tf
x = tf.placeholder(tf.string)
with tf.Session() as sess:
output = sess.run(x, feed_dict={x: 'Hello World'})
```

Use the `feed_dict`

parameter in `tf.session.run()`

to set the placeholder tensor. The above example shows the tensor `x`

is set to the string `"Hello, world"`

.

## Tensorflow basic operations

Now we have covered almost thing to get started for basic operations in TensorFlow.

### 1. Addition

```
x = tf.add(5, 2) # 7
```

You’ll start with the add function. The `tf.add()`

function does exactly what you expect it to do.

### 2. Subtraction and Multiplication

Here’s an example with subtraction and multiplication.

```
x = tf.subtract(10, 4) # 6
y = tf.multiply(2, 5) # 10
```

### 3. More Basic Operation

Following is a list of commonly used operations. The idea is the same as above. Each operation requires one or more arguments.

- tf.div(a,b)
- tf.pow(a,b)
- tf.exp(a)
- tf.sqrt(a)

## Programming Elements in Tensorflow

Unlike other programming languages, TensorFlow allows you to assign data to three different data elements:

- Constants
- Variables
- Placeholders

#### Constants

Constants are parameters with values that do not change. We use the `tf.constant()`

command to define a constant.

```
a = tf.constant(2.0, tf.float32)
```

#### Variables

Variables allow us to add new trainable parameters to the graph. To define a variable, we use the `tf.Variable()`

command and initialize them before running the graph in a session.

```
W = tf.Variable([.3],dtype=tf.float32)
b = tf.Variable([-.3],dtype=tf.float32)
x = tf.placeholder(tf.float32)
linear_model = W*x+b
```

#### Placeholders

Placeholders allow us to feed data to a TensorFlow model from outside a model. It permits value to be assigned later. To define a placeholder, we use the `tf.placeholder()`

command.

```
a = tf.placeholder(tf.float32)
b = a*2
with tf.Session() as sess:
result = sess.run(b,feed_dict={a:3.0})
```

**Next**: In the next tutorial, we will read about Linear regression, hypothesis, cost function, and predicting house price using Tensorflow.