TensorFlow with cmd interface for windows on AWS
Tags: aws, cloud, machinelearning, tensorflow
Published: 2022-11-27 15:50:46

# Objectives
In this post, you will:
- run python commands on python interpreter
- create a session to build a simple graph with tensorflow 
- perform some mathematical operations on tensors in TensorFlow.
- understand how graphs are used to define computations and sessions are used to perform the computations defined in a graph.
- demonstrate how to use TensorFlow variables to store the results of intermediate computations.

# Prerequisites
1- You should have the ability to connect with EC2 instance (local port) from your local host. If you don't know how to do that, read my blog on medium from [here](https://a00ayad00.medium.com/how-to-connect-to-ports-on-a-remote-server-through-the-encrypted-ssh-channel-for-windows-b4ed0281ad0d?source=user_profile---------0----------------------------) or on dev from [here](https://dev.to/aws-builders/how-to-connect-to-ports-on-a-remote-server-through-the-encrypted-ssh-channel-for-windows-7kc)

2- you have to have an evironment on your terminal that have Python 3.6 and tensorflow library.**_I'll explain how to do this later_**.

### Step 1
After you connect to your EC2 instance, enter the following command in your SSH shell to load the Python 3.6 TensorFlow virtual environment in the AMI(EC2 instance):

```
source activate Your_Environment_Name
```
For example, If you named your environment as `tensorflow_p36`, then enter the following:

```
source activate tensorflow_p36
```

- The virtual environment sets all the environment variables required to use libraries and binaries required for TensorFlow.
- (tensorflow_p36) is prepended to your shell prompt to let you know you are using the TensorFlow Python 3.6 virtual environment.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hah67ziu6sq1beo3wfkv.png)

### Step 2
Start the interactive Python interpreter by entering:

```
python
```

### Step 3
Enter the following import statements to import the TensorFlow module:

```
import tensorflow as tf
```

- The TensorFlow module is conventionally imported as tf.
- Don't pay attention to any warning messages you face just now, you can ignore them and still complete without any issue.

### Step 4
To define a dataflow graph with two constant tensors as input and use the tf.add operation to produce the output, enter the following and press enter:

```
# Explicitly create a computation graph
graph = tf.Graph()
with graph.as_default():
    # Declare one-dimensional tensors (vectors)
    input1 = tf.constant([1.0, 2.0])
    input2 = tf.constant([3.0, 4.0])
    # Add the two tensors
    output = tf.add(input1, input2)
```

The graph keeps track of all the inputs and operations you define so the results can be computed when you run a TensorFlow session with the graph.

### Step 4
To print the graph to see that it stored the inputs and operations, add the following and press enter:

```
print(graph.get_operations())
```
After a few moments you will see the following output:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/80ilhaqn7csa836kyw80.png)

- The list of each operation corresponding to the two input constants and the addition operation are displayed.
- Default unique names are shown in single quotations.
- You can set the names when you declare the operation by passing a named argument called `name`.

### Step 5
Evaluate the graph by creating a session with the graph and calling the `output.eval()` function:

```
# Evaluate the graph in a session
with tf.Session(graph = graph):
    result = output.eval()
    print("result: ", result)
```
After a few moments you will see the following output:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/476kjkbbk2jr3k17bwq6.png)

- The output displays an information message letting you know that the session will run on the instance's graphics processing unit (GPU).
- The result is printed on the last line.

### Step 7
When you are only using a single graph in a session, you can use the default graph as shown in the following example that repeats the computation using the default graph:

```
# Evaluate using the default graph
with tf.Session():
    input1 = tf.constant([1.0, 2.0])
    input2 = tf.constant([3.0, 4.0])
    output = tf.add(input1, input2)
    # Show the operations in the default graph
    print(tf.get_default_graph().get_operations())
    result = output.eval()
    print("result: ", result)
```

- In the above code, the default graph is implicitly passed to all Tensorflow API functions.
- It can be convenient to use the default graph, but you may need multiple graphs when you develop separate training and test graphs for machine learning algorithms.

### Step 8
To multiply a matrix by a vector add the following and press enter:

```
matmul_graph = tf.Graph()
with matmul_graph.as_default():
    # Declare a 2x2 matrix and a 2x1 vector
    matrix = tf.constant([[1.0, 2.0], [3.0, 4.0]])
    vector = tf.constant([[1.0], [2.0]])
    # Matrix multiply (matmul) the two tensors
    output = tf.matmul(matrix, vector)
 
with tf.Session(graph = matmul_graph):
    result = output.eval()
    print(result)
```

After a few moments you will see the following output:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/gte2w34s4cvowyzn0nnu.png)

- You have now seen how to add vectors and multiply a matrix by a vector in TensorFlow.
- These two operations are the building blocks of several machine learning algorithms.
- The examples have only used constant inputs so far.
- TensorFlow supports using variables to allow tensors to be updated with different values as graph evaluation proceeds.

### Step 9
Use variables to store the result of repeatedly multiplying a matrix by a vector as in the following annotated example:

```
# Evaluate a matrix-vector multiplication
var_graph = tf.Graph()
with var_graph.as_default():
    # Declare a constant 2x2 matrix and a variable 2x1 vector
    matrix = tf.constant([[1.0, 1.0], [1.0, 1.0]])
    vector = tf.Variable([[1.0], [1.0]])
    # Multiply the matrix and vector 4 times
    for _ in range(4):
        # Repeatedly update vector with the multiplication result
        vector = tf.matmul(matrix, vector)
with tf.Session(graph = var_graph):
    # Initialize the variables we defined above.
    tf.global_variables_initializer().run()
    result = vector.eval()
    print(result)
```

After a few moments you will see the following output:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/a933e28509k6kg19fu3q.png)

- The output value of vector shows that the value has been updated.
- This is similar to what you would expect using a variable in Python.
- One catch is that variables must be initialized with an explicit call.
- `tf.global_variables_initializer().run()` initializes all variables in a global variable collection. By default, every variable is added to the global variable collection.

### Step 10
Exit the Python interpreter by entering:
```
exit()
```
In the next post, I'll explain how to use Jupyter Notebook to run your code.

### Step 11
Deactivate the TensorFlow virtual environment:

```
source deactivate
```

- The _tensorflow_p36_ prefix(_Environment Name_) of the shell prompt is no longer displayed.
- The Jupyter notebook server needs to be started outside of any virtual environment to be able to discover the available virtual environments.

<br>
[GitHub](https://github.com/a00ayad00)
[LinkedIn](https://www.linkedin.com/in/a00ayad00)
[Facebook](https://m.facebook.com/a00ayad00)
[Medium](https://a00ayad00.medium.com/)