<SYSTEM_TASK:>
Given the following text description, write Python code to implement the functionality described below step by step
<END_TASK>
<USER_TASK:>
Description:
 <div style="text-align
Step1:  <a id="ref3"></a>
Building a Graph
As we said before, TensorFlow works as a graph computational model. Let's create our first graph.
To create two source operations which will output numbers we will define two constants
Step2:  After that, let's make an operation over these variables. The function tf.add() adds two elements (you could also use c = a + b).
Step3:  Then TensorFlow needs to initialize a session to run our code. Sessions are, in a way, a context for creating a graph inside TensorFlow. Let's define our session
Step4:  Let's run the session to get the result from the previous defined 'c' operation
Step5:  Close the session to release resources
Step6:  To avoid having to close sessions every time, we can define them in a with block, so after running the with block the session will close automatically
Step7:  Even this silly example of adding 2 constants to reach a simple result defines the basis of TensorFlow. Define your edge (In this case our constants), include nodes (operations, like tf.add), and start a session to build a graph.
<a id="ref2"></a>
TensorFlow Basic Elements
Tensor
Variable
Operation
Session
Placeholder
Tensorboard
What is the meaning of Tensor?
<div class="alert alert-success alertsuccess" style="margin-top
Step8:  <a id="ref5"></a>
Why Tensors?
The Tensor structure helps us by giving the freedom to shape the dataset the way we want.
And it is particularly helpful when dealing with images, due to the nature of how information in images are encoded,
Thinking about images, its easy to understand that it has a height and width, so it would make sense to represent the information contained in it with a two dimensional strucutre (a matrix)... until you remember that images have colors, and to add information about the colors, we need another dimension, and thats when Tensors become particulary helpful.
Images are encoded into color channels, the image data is represented into each color intensity in a color channel at a given point, the most common one being RGB, which means Red, Blue and Green. The information contained into an image is the intensity of each channel color into the width and height of the image, just like this
Step9:  Let's first create a simple counter, a variable that increases one unit at a time
Step10:  Variables must be initialized by running an initialization operation after having launched the graph.  We first have to add the initialization operation to the graph
Step11:  We then start a session to run the graph, first initialize the variables, then print the initial value of the state variable, and then run the operation of updating the state variable and printing the result after each update
Step12:  <a id="ref7"></a>
Placeholders
Now we know how to manipulate variables inside TensorFlow, but what about feeding data outside of a TensorFlow model? 
If you want to feed data to a TensorFlow model from outside a model, you will need to use placeholders.
So what are these placeholders and what do they do? 
Placeholders can be seen as "holes" in your model, "holes" which you will pass the data to, you can create them using <br/> <b>tf.placeholder(datatype)</b>, where <b>datatype</b> specifies the type of data (integers, floating points, strings, booleans) along with its precision (8, 16, 32, 64) bits.
The definition of each data type with the respective python sintax is defined as
Step13:  And define a simple multiplication operation
Step14:  Now we need to define and run the session, but since we created a "hole" in the model to pass the data, when we initialize the session we are obligated to pass an argument with the data, otherwise we would get an error.
To pass the data to the model we call the session with an extra argument <b> feed_dict</b> in which we should pass a dictionary with each placeholder name folowed by its respective data, just like this
Step15:  Since data in TensorFlow is passed in form of multidimensional arrays we can pass any kind of tensor through the placeholders to get the answer to the simple multiplication operation
Step16:  <a id="ref8"></a>
Operations
Operations are nodes that represent the mathematical operations over the tensors on a graph. These operations can be any kind of functions, like add and subtract tensor or maybe an activation function.
tf.matmul, tf.add, tf.nn.sigmoid are some of the operations in TensorFlow. These are like functions in python but operate directly over tensors and each one does a specific thing. 
<div class="alert alert-success alertsuccess" style="margin-top
Step17:  <a id="ref8"></a>
Tensorboard
TensorBoard is a suite of web applications for inspecting and understanding your TensorFlow runs and graphs. TensorBoard currently supports five visualizations
<ASSISTANT_TASK:>
Python Code:
import tensorflow as tf
Explanation: <div style="text-align:center"><img src = "https://www.tensorflow.org/_static/images/tensorflow/logo.png"></div>
<a id="ref2"></a>
How does TensorFlow work?
TensorFlow defines computations as Graphs, and these are made with operations (also know as “ops”). So, when we work with TensorFlow, it is the same as defining a series of operations in a Graph.
To execute these operations as computations, we must launch the Graph into a Session. The session translates and passes the operations represented into the graphs to the device you want to execute them on, be it a GPU or CPU.
For example, the image below represents a graph in TensorFlow. W, x and b are tensors over the edges of this graph. MatMul is an operation over the tensors W and x, after that Add is called and add the result of the previous operator with b. 
<img src='https://ibm.box.com/shared/static/a94cgezzwbkrq02jzfjjljrcaozu5s2q.png'>
Importing TensorFlow
<p>To use TensorFlow, we need to import the library. We imported it and optionally gave it the name "tf", so the modules can be accessed by __tf.module-name__:
End of explanation
a = tf.constant([2])
b = tf.constant([3])
Explanation: <a id="ref3"></a>
Building a Graph
As we said before, TensorFlow works as a graph computational model. Let's create our first graph.
To create two source operations which will output numbers we will define two constants:
End of explanation
c = tf.add(a,b)
Explanation: After that, let's make an operation over these variables. The function tf.add() adds two elements (you could also use c = a + b).
End of explanation
session = tf.Session()
Explanation: Then TensorFlow needs to initialize a session to run our code. Sessions are, in a way, a context for creating a graph inside TensorFlow. Let's define our session:
End of explanation
result = session.run(c)
print(result)
Explanation: Let's run the session to get the result from the previous defined 'c' operation:
End of explanation
session.close()
Explanation: Close the session to release resources:
End of explanation
with tf.Session() as session:
    result = session.run(c)
    print(result)
Explanation: To avoid having to close sessions every time, we can define them in a with block, so after running the with block the session will close automatically:
End of explanation
Scalar = tf.constant([2])
Vector = tf.constant([5,6,2])
Matrix = tf.constant([[1,2,3],[2,3,4],[3,4,5]])
Tensor = tf.constant( [ [[1,2,3],[2,3,4],[3,4,5]] , [[4,5,6],[5,6,7],[6,7,8]] , [[7,8,9],[8,9,10],[9,10,11]] ] )
with tf.Session() as session:
    result = session.run(Scalar)
    print ("Scalar (1 entry):\n %s \n" % result)
    result = session.run(Vector)
    print ("Vector (3 entries) :\n %s \n" % result)
    result = session.run(Matrix)
    print ("Matrix (3x3 entries):\n %s \n" % result)
    result = session.run(Tensor)
    print ("Tensor (3x3x3 entries) :\n %s \n" % result)
Explanation: Even this silly example of adding 2 constants to reach a simple result defines the basis of TensorFlow. Define your edge (In this case our constants), include nodes (operations, like tf.add), and start a session to build a graph.
<a id="ref2"></a>
TensorFlow Basic Elements
Tensor
Variable
Operation
Session
Placeholder
Tensorboard
What is the meaning of Tensor?
<div class="alert alert-success alertsuccess" style="margin-top: 20px">
<font size = 3><strong>In TensorFlow all data is passed between operations in a computation graph, and these are passed in the form of Tensors, hence the name of TensorFlow.</strong></font>
<br>
<br>
The word __tensor__ from new latin means "that which stretches". It is a mathematical object that is named __tensor__  because an early application of tensors was the study of materials stretching under tension. The contemporary meaning of tensors can be taken as multidimensional arrays. 
<p></p>
</div>
What are multidimensional arrays here?
<table style="width:100%">
  <tr>
    <td><b>Dimension</b></td>
    <td><b>Physical Representation</b></td> 
    <td><b>Mathematical Object</b></td>
    <td><b>In Code</b></td>
  </tr>
  <tr>
    <td>Zero </td>
    <td>Point</td> 
    <td>Scalar (Single Number)</td>
    <td>[ 1 ]</td>
  </tr>
  <tr>
    <td>One</td>
    <td>Line</td> 
    <td>Vector (Series of Numbers) </td>
    <td>[ 1,2,3,4,... ]</td>
  </tr>
   <tr>
    <td>Two</td>
    <td>Surface</td> 
    <td>Matrix (Table of Numbers)</td>
    <td>[ [1,2,3,4,...], [1,2,3,4,...], [1,2,3,4,...],... ]</td>
  </tr>
   <tr>
    <td>Three</td>
    <td>Volume</td> 
    <td>Tensor (Cube of Numbers)</td>
    <td>[ [[1,2,...], [1,2,...], [1,2,...],...], [[1,2,...], [1,2,...], [1,2,...],...], [[1,2,...], [1,2,...], [1,2,...] ,...]... ]</td>
  </tr>
</table>
<a id="ref4"></a>
Defining multidimensional arrays using TensorFlow
Now we will try to define such arrays using TensorFlow:
End of explanation
state = tf.Variable(0)
Explanation: <a id="ref5"></a>
Why Tensors?
The Tensor structure helps us by giving the freedom to shape the dataset the way we want.
And it is particularly helpful when dealing with images, due to the nature of how information in images are encoded,
Thinking about images, its easy to understand that it has a height and width, so it would make sense to represent the information contained in it with a two dimensional strucutre (a matrix)... until you remember that images have colors, and to add information about the colors, we need another dimension, and thats when Tensors become particulary helpful.
Images are encoded into color channels, the image data is represented into each color intensity in a color channel at a given point, the most common one being RGB, which means Red, Blue and Green. The information contained into an image is the intensity of each channel color into the width and height of the image, just like this:
<img src='https://ibm.box.com/shared/static/xlpv9h5xws248c09k1rlx7cer69y4grh.png'>
So the intensity of the red channel at each point with width and height can be represented into a matrix, the same goes for the blue and green channels, so we end up having three matrices, and when these are combined they form a tensor. 
<a id="ref6"></a>
Variables
Now that we are more familiar with the structure of data, we will take a look at how TensorFlow handles variables.
To define variables we use the command tf.variable().
To be able to use variables in a computation graph it is necessary to initialize them before running the graph in a session. This is done by running tf.global_variables_initializer().
To update the value of a variable, we simply run an assign operation that assigns a value to the variable:
End of explanation
one = tf.constant(1)
new_value = tf.add(state, one)
update = tf.assign(state, new_value)
Explanation: Let's first create a simple counter, a variable that increases one unit at a time:
End of explanation
init = tf.global_variables_initializer()
Explanation: Variables must be initialized by running an initialization operation after having launched the graph.  We first have to add the initialization operation to the graph:
End of explanation
with tf.Session() as session:
  session.run(init)
  print(session.run(state))
  for i in range(3):
    session.run(update)
    print(session.run(state))
Explanation: We then start a session to run the graph, first initialize the variables, then print the initial value of the state variable, and then run the operation of updating the state variable and printing the result after each update:
End of explanation
a=tf.placeholder(tf.float32)
Explanation: <a id="ref7"></a>
Placeholders
Now we know how to manipulate variables inside TensorFlow, but what about feeding data outside of a TensorFlow model? 
If you want to feed data to a TensorFlow model from outside a model, you will need to use placeholders.
So what are these placeholders and what do they do? 
Placeholders can be seen as "holes" in your model, "holes" which you will pass the data to, you can create them using <br/> <b>tf.placeholder(datatype)</b>, where <b>datatype</b> specifies the type of data (integers, floating points, strings, booleans) along with its precision (8, 16, 32, 64) bits.
The definition of each data type with the respective python sintax is defined as:
|Data type  |Python type|Description|
| --------- | --------- | --------- |
|DT_FLOAT   |tf.float32 |32 bits floating point.|
|DT_DOUBLE  |tf.float64 |64 bits floating point.|
|DT_INT8    |tf.int8    |8 bits signed integer.|
|DT_INT16   |tf.int16   |16 bits signed integer.|
|DT_INT32   |tf.int32   |32 bits signed integer.|
|DT_INT64   |tf.int64   |64 bits signed integer.|
|DT_UINT8   |tf.uint8   |8 bits unsigned integer.|
|DT_STRING  |tf.string  |Variable length byte arrays. Each element of a Tensor is a byte array.|
|DT_BOOL    |tf.bool    |Boolean.|
|DT_COMPLEX64   |tf.complex64   |Complex number made of two 32 bits floating points: real and imaginary parts.|
|DT_COMPLEX128  |tf.complex128  |Complex number made of two 64 bits floating points: real and imaginary parts.|
|DT_QINT8   |tf.qint8   |8 bits signed integer used in quantized Ops.|
|DT_QINT32  |tf.qint32  |32 bits signed integer used in quantized Ops.|
|DT_QUINT8  |tf.quint8  |8 bits unsigned integer used in quantized Ops.|
<div style="text-align:center">[[Table Source]](https://www.tensorflow.org/versions/r0.9/resources/dims_types.html)</div>
So we create a placeholder:
End of explanation
b=a*2
Explanation: And define a simple multiplication operation:
End of explanation
with tf.Session() as sess:
    result = sess.run(b,feed_dict={a:3.5})
    print (result)
Explanation: Now we need to define and run the session, but since we created a "hole" in the model to pass the data, when we initialize the session we are obligated to pass an argument with the data, otherwise we would get an error.
To pass the data to the model we call the session with an extra argument <b> feed_dict</b> in which we should pass a dictionary with each placeholder name folowed by its respective data, just like this:
End of explanation
dictionary={a: [ [ [1,2,3],[4,5,6],[7,8,9],[10,11,12] ] , [ [13,14,15],[16,17,18],[19,20,21],[22,23,24] ] ] }
with tf.Session() as sess:
    result = sess.run(b,feed_dict=dictionary)
    print (result)
Explanation: Since data in TensorFlow is passed in form of multidimensional arrays we can pass any kind of tensor through the placeholders to get the answer to the simple multiplication operation:
End of explanation
a = tf.constant([5])
b = tf.constant([2])
c = tf.add(a,b)
d = tf.subtract(a,b)
with tf.Session() as session:
    result = session.run(c)
    print ('c =: %s' % result)
    result = session.run(d)
    print ('d =: %s' % result)
Explanation: <a id="ref8"></a>
Operations
Operations are nodes that represent the mathematical operations over the tensors on a graph. These operations can be any kind of functions, like add and subtract tensor or maybe an activation function.
tf.matmul, tf.add, tf.nn.sigmoid are some of the operations in TensorFlow. These are like functions in python but operate directly over tensors and each one does a specific thing. 
<div class="alert alert-success alertsuccess" style="margin-top: 20px">Other operations can be easily found in: https://www.tensorflow.org/versions/r0.9/api_docs/python/index.html</div>
End of explanation
import tensorflow as tf
with tf.name_scope("Operations"):
    with tf.name_scope("Scope_a"):
        a = tf.add(1, 2, name="a")
        b = tf.multiply(a, 3, name="b")
    with tf.name_scope("Scope_b"):
        c = tf.add(4, 5, name="c")
        d = tf.multiply(c, 6, name="d")
with tf.name_scope("Scope_c"):
    e = tf.multiply(4, 5, name="e")
    f = tf.div(c, 6, name="f")
g = tf.add(b, d,  name="g")
h = tf.multiply(g, f, name="h")
with tf.Session() as sess:
    print(sess.run(h))
with tf.Session() as sess:
    writer = tf.summary.FileWriter("/home/raghav/TECH/output4", sess.graph)
    print(sess.run(h))
    writer.close()
Explanation: <a id="ref8"></a>
Tensorboard
TensorBoard is a suite of web applications for inspecting and understanding your TensorFlow runs and graphs. TensorBoard currently supports five visualizations: scalars, images, audio, histograms, and graphs. The computations you will use in TensorFlow for things such as training a massive deep neural network, can be fairly complex and confusing, TensorBoard will make this a lot easier to understand, debug, and optimize your TensorFlow programs.
This is what a tensorboard looks like:
<img src='https://learningtensorflow.com/images/ezgif.com-video-to-gif.gif'>
End of explanation
<END_TASK>