## Introduction to Tensorflow variable

The following article provides an outline for the Tensorflow variable. All operations in TensorFlow use tensors, and all values in a tensor have the same data type. As a result, TensorFlow predicts the shape when you print tensor. On the other hand, the TensorFlow shape property can be used to obtain the tensor’s shape.

### What is the TensorFlow variable?

When building a deep learning model in TensorFlow, we require Variables to represent the model’s parameters. TensorFlow Variables are tensor-based in-memory buffers that persist across several graph executions. As training progresses, the value of a variable will change, and each variation will get the model closer to the ideal system.

All computations in TensorFlow go through one or more sensors. A tensor can be expressed in a scalar format or with a multidimensional format. A tf.tensor is a three-property object that includes:

- A distinctive label (name)
- a measurement (shape)
- a type of data (dtype)

Variable characteristics

- Between executions of a session, a variable retains its value.
- An executing session must initialise a variable.
- Variables are objects that belong to the Variable class.
- Variables can be used to save data in arrays and to proceed it using TensorFlow operations.
- Before a graph may be used for the first time, variables must be explicitly initialized.
- We can save the values saved in variables to disc and then retrieve them for later use.

### Create a variable

The Variable class can be used to reflect the fact that data always arrives with different values. It will depict a node with constantly changing values. We can use the tf.getvariable() method to generate a variable. Variable initializers must be run before any other operations in your model can be executed. The simplest approach to achieve this is to create an op that executes all of the variable initializers before using the model.

`Var1 = tf. Variable (<starting Val>, name=<optional>)`

The first parameter determines the variable’s initial value, while the second optional parameter defines the variable’s name.

library (tensor flow)

`my_var <- tf$Variable (tf$zeros (shape (1,2,3)))`

The above format creates three-dimensional shapes done with zeros. They have a default dtype tf@float32. Most TensorFlow optimizers feature specialised ops that update variable values efficiently using a gradient descent-like technique.

`<- tf$Variable (0)`

var$assign_add(10)

Variables in TensorFlow must be initialised before they may be used. Constant tensors are the polar opposite of constant tensors.

`We = tf. Variable(tf. zeros((2,2)), name="weights")`

Res = tf.Variable(tf.random_normal((2,2)), name="random weights")

with tf.Session() as ses1:

ses1.run(tf.initialize_all_variables())

print(ses1.run(We))

print(ses1.run(Res))

Here weights is a variable object that could be assigned from a constant. Hundreds of variables can be found in complicated TensorFlow models.

To avoid collisions, tf.variable scope() provides simple name-spacing.

Within a variable scope, tf.get variable() creates/accesses variables.

### TensorFlow variable Lifecycles

The lifecycle of a tf.Variable instance in Python-based TensorFlow is the same as that of other Object storage. When a variable has no references, it is immediately deallocated. Variables can also be given names, which makes them easier to track and debug. Two variables with the same name are allowed.

`.m= tf.Variable(my_tensor, name="John")`

n= tf.Variable(my_tensor + 1, name="John")

print (m == n)

Therefore, this produces

`tf.Tensor(`

[[False False]
[False False]], shape= (2, 2), dtype=bool)

When we declare a Variable, we may use the tf.assign() function to alter its value in the future, and we can use a value or an action to initialise it.

The function tf.global variables initializer () initializes all variables in the code with the value supplied as a parameter, but it does it in async mode, which means it doesn’t operate properly when variables have dependencies.

Next, we shall see how to update a variable.

`Updating Variable State`

state = tf.Variable(0, name="increase")

nval = tf.add (state, tf. constant (1))

update = tf. assign (state, nval)

with tf.Session() as se1:

se1.run(tf.initialize_all_variables ())

print(se1.run(state))

for i _ in range(3):

se1.run(update)

print(se1.run(state))

### TensorFlow variable Examples

Different examples are mentioned below:

#### Example #1 – Using the loss of training

`x_hat = tf.constant(36, name='x_hat')`

x = tf.constant(39, name='x')

loss = tf.Variable((x - x_hat)**2, name='loss')

init = tf.global_variables_initializer()

tf.Session() as session:

session.run(init)

print(session.run(loss))

**Explanation**

loss=(-y). Defining a constant to 36 and creating a variable for loss manipulation. Next, creating a session and output is displayed.

**Output**

**9**

#### Example #2

`from __future__ import absolute_import`

from __future__ import division

from __future__ import print_function

import tensorflow as tf

va1 = tf.Variable(11, name="va1")

se1 = tf.Session()

init = tf. global_variables_initializer ()

se1.run(init)

print(se1.run(va1))

se1.run(va1.assign(12))

print(se1.run(va1))

se1.run(va1.assign_add(12))

print(se1.run(va1))

se1.run(va1.assign_sub(4))

print(se1.run(va1))

**Explanation**

The tensor uses a variable to initialize a value in the above code. Next, add, and sub-functions are used to increment and decrement an assigned tensor value.

**Output**

#### Example #3

`import tensorflow as tf`

vble = tf.get_variable("vble", [1, 2])

print(vble)

var_i = tf.get_variable("var_i", [1, 2], dtype=tf.int32, initializer=tf.zeros_initializer)

print(var_i)

t_ct = tf.constant([[11, 12],[13, 14]])

var_2 = tf.get_variable("var_2", dtype=tf.int32, initializer=t_ct)

print(var_2)

**Explanation**

Because the shape of ‘initializer’ is used, there is no need to include the ‘values’ if the initializer is supplied. The above code’s output is as follows:

**Output**

#### Example #4

`from __future__ import absolute_import`

from __future__ import division

from __future__ import print_function

import tensorflow as tf

tens1 = tf.constant([2.1, 3.1, 4.1])

varX = tf.Variable(tens1 , name="varX")

varY = tf.Variable([12, 21.1, 34.5], name="varY")

varZ = tf.Variable(["AU", "IND"], name="varZ")

varZY = tf.Variable([varX, varY], name="varZY")

print(format(varX))

print(format(varY))

print(format(varZ))

print(format(varZY))

**Explanation**

Here a tensor creates four different variables with values. The output takes the shape of the variable to display an output.

**Output**

#### Example #5 – Variable Assignment

`from __future__ import absolute_import`

from __future__ import division

from __future__ import print_function

import tensorflow as tf

varM = tf.Variable(5, name="varM")

se1 = tf.Session()

init = tf.global_variables_initializer ()

se1.run(init)

print(se1.run(varM))

se1.run(varM.assign(15))

print(se1.run(varM))

se1.run(varM.assign_add(10))

print(se1.run(varM))

se1.run(varM.assign_sub(4))

print(se1.run(varM))

** **

**Explanation**

Generally, we utilize the Variable.assign(), Variable.assign add (), and Variable.assign sub () methods to update, increment, and reduce the value of Variable. In the above code, we have used Tensor flow with a variable assignment where we first create a variable varM and started a session by initialization. Next, to assign a new value to a session, use the assign () method. And the output is shown below after increment and decrement operation.

**Output**

#### Example #6

`import numpy as np`

import tensorflow as tf

zz= tf.Variable(0, dtype=tf.float32)

cost = 15 + 3*zz + zz*zz

tr1 = tf.train.GradientDescentOptimizer(0.01). minimize(cost)

init = tf.global_variables_initializer()

se1 = tf.Session()

se1.run(init)

print(se1.run(zz))

se1.run(tr1)

print(se1.run(zz))

for j in range (10000):

se1.run(tr1)

print(se1.run(zz))

**Explanation**

The Variable was initially set to 0, then changed to -0.049999997 after only one step of gradient descent, and finally to -2.499994 after 10.000 steps. An interactive session is essential when numerous separate sessions are executed in the same script.

**Output**

### Conclusion

Finally, this article discusses the tensor flow variables and their initialization in depth. We’ve also seen a few examples of how variables affect a tensor flow in Python. To initialize a variable as a constant, we must call a function Object (). the initial value can be handed in as an argument. Object() variables may be simply added to the computational graph by using a function.

### Recommended Articles

This is a guide to Tensorflow variable. Here we discuss a few examples of how variables affect a tensor flow in Python and the tensor flow variables and their initialization in depth. You may also have a look at the following articles to learn more –

11 Online Courses | 3 Hands-on Projects | 55+ Hours | Verifiable Certificate of Completion

4.5

View Course

Related Courses