# Getting Started with TensorFlow the Easy Way (Part 1)

*This is part 1 of a series of articles on how to get started with TensorFlow.*

Given the recent spike in interest in the deep learning field, there is often a fiery debate that happens among data scientists — which framework is the best? This, like so many other things in this field, is entirely subjective.

But one framework, that most experts like and use, is Google’s TensorFlow™. It’s the most widely used framework by industry experts and researchers, it represents a good starting touch point for newcomers to deep learning.

TensorFlow™ is a flexible architecture that allows easy deployment of machine learning computation across a variety of platforms (CPUs, GPUs, TPUs), from desktops to clusters of servers to mobile and IoT devices.

In this series, we shall cover the bread and butter of Tensorflow framework with lots of interesting visualizations and side-projects to work on.

# Prerequisites

To make the most out of this tutorial, we expect the following prerequisites are met:

- Basic understanding of Python
- Basics of Machine Learning
- Familiarity with Jupyter Notebooks

We will cover the progress of **Learning Tensorflow the easy way **in the following parts;

*Part 1: Tensorflow Installation and Setup, Syntax, and Graphs*

*Part 2: Variables and Placeholders in Tensorflow*

*Part 3: Implementing a Regression Example in Tensorflow*

*Part 4: Implementing a Classification in Tensorflow*

**Part 1 : ***Tensorflow Installation and Setup, Syntax, and Graphs*

*Tensorflow Installation and Setup, Syntax, and Graphs*

# Installation and Setup:

Tensorflow supports the following 64-bit opertating systems.

- Ubuntu 16.04 or later
- Windows 7 or later
- macOS 10.12.6 (Sierra) or later (no GPU support)
- Raspbian 9.0 or later

The pip installation requires Python 2.7, 3.4, 3.5, or 3.6. You may check your Python and pip version by using the following commands:

`python3 --version`

pip3 --version

It should output the your python and pip versions. It is recommended that you setup a virtual environment. I have anaconda installed that supports many dependencies of tensorflow. We can proceed with a conda command to create a python 3.5 virtual environment.

`conda create -n py35 python=3.5`

This should take a while. Now, you can switch to environment using `source activate py35`

Once, you are in your newly created environment, you can install tensorflow with pip command;

`pip install -- tensorflow==1.3`

Let’s open up a jupyter notebook using `jupyter notebook`

command and import tenforflow using the following command.

import tensorflow as tf

print("Tensorflow version: {}".format(tf.__version__))Output:

Tensorflow version: 1.3.0

Note that this tutorial is made on 1.3.0 version and the syntax might differ if you use any previous version of tensorflow.

# Tensorflow Basics: Syntax and Graphs

## Understanding the “Tensor” in TensorFlow

**Tensors **are simply arrays of numbers, or functions, that transform according to certain rules under a change of coordinates. We typically see them in relations such as the dot product, the cross product, and linear maps.

Now, as previously mentioned that tensors are arrays of numbers. But, it should be noted that Tensors are not another name for multi-dimensional arrays. There is a significant difference between Tensor and multi-dimensional arrays. Simply put, multi-dimensional arrays are data structures for representing tensor in a coordinate system.

## The story of Graphs in Tensorflow

The Tensorflow works on the *tensors *and their *flow *of operations through a computation graph. Hence the name; Tensor+flow = Tensorflow!

A computational graph is a series of TensorFlow operations arranged into a graph of nodes.

At first we create a model which is a *computation graph with ***tensors **as objects. Then we create a **session **in which we run the computation all at once. Don’t worry if the concept is glitchy here. Let us implement the same in code to understand it better

import tensorflow as tffirst_string = tf.constant('Analytics')

second_string = tf.constant(' Vidhya')

Now, if you check the type of either variables with `type(first_string)`

command. You should see that it is a Tensor object not a string.

`Out []: tensorflow.python.framework.ops.Tensor`

Now, lets’ try and add both the strings and try to print it. The type remains the same. But, the output is not what is usually expected.

combined_string = (first_string + second_string)

print (type(combined_string))

print (combined_string)Out []: <class 'tensorflow.python.framework.ops.Tensor'>

Tensor("add:0", shape=(), dtype=string)

This is how computational graph works. The `combined_string`

is not directly the result of addition of two strings but is just an operation to be carried out. On this very basis the tensorflow works. First you define a path and later on execute your pipeline in a session.

Now, to see the expected results we have to run the session for the computation to happen. You can run it using the following command;

with tf.Session() as sess:

result = sess.run(combined_string)

print (result)Out []: b'Analytics Vidhya'

We use `with tf.Session()…`

as it automatically opens and closes the session after running the computation for us.

To get a hang of it, lets try out some matrix operations in a bulk code that take two matrices as input and then multiply them.

Matrix_1 = tf.constant([ [1,3],

[2,6]])

Matrix_2 = tf.constant([ [13,26],

[23,52]])

print("The Shape of Matrix 1 is {} and of Matrix 2 is {}".format(Matrix_1.get_shape(), Matrix_2.get_shape()))MatMul = tf.matmul(Matrix_1, Matrix_2)with tf.Session() as sess:

result = sess.run(MatMul)

print(">> Output")

print(result)Out []: The Shape of Matrix 1 is (2, 2) and of Matrix 2 is (2, 2)

>> Output

[[ 82 182]

[164 364]]

So in general you need to remember the following things:

- Graphs are set of nodes
- The connections are referred as edges
- In Tensorflow, each node is an operation with some inputs that supplies output after execution

That’s all for this introductory part. The Jupyter notebook is available on GitHub here. We shall be covering the next concepts in

*Part 2: Variables and Placeholders in TensorFlow and Operations*

Stay tuned. And, don't forget to initialize your tensors. For any help or suggestion, do use the comment section below.