Now, we will explore some of the operations in TensorFlow using the eager execution mode:
x = tf.constant([1., 2., 3.])
y = tf.constant([3., 2., 1.])
Let's start with some basic arithmetic operations.
Use tf.add to add two numbers:
sum = tf.add(x,y)
sum.numpy()
array([4., 4., 4.], dtype=float32)
The tf.subtract function is used for finding the difference between two numbers:
difference = tf.subtract(x,y)
difference.numpy()
array([-2., 0., 2.], dtype=float32)
The tf.multiply function is used for multiplying two numbers:
product = tf.multiply(x,y)
product.numpy()
array([3., 4., 3.], dtype=float32)
Divide two numbers using tf.divide:
division = tf.divide(x,y)
division.numpy()
array([0.33333334, 1. , 3. ], dtype=float32)
The dot product can be computed as follows:
dot_product = tf.reduce_sum(tf.multiply(x, y))
dot_product.numpy()
10.0
Next, let's find the index of the minimum and maximum elements:
x = tf.constant([10, 0, 13, 9])
The index of the minimum value is computed using tf.argmin():
tf.argmin(x).numpy()
1
The index of the maximum value is computed using tf.argmax():
tf.argmax(x).numpy()
2
Run the following code to find the squared difference between x and y:
x = tf.Variable([1,3,5,7,11])
y = tf.Variable([1])
tf.math.squared_difference(x,y).numpy()
[ 0, 4, 16, 36, 100]
Let's try typecasting; that is, converting from one data type into another.
Print the type of x:
print x.dtype
tf.int32
We can convert the type of x, which is tf.int32, into tf.float32 using tf.cast, as shown in the following code:
x = tf.cast(x, dtype=tf.float32)
Now, check the x type. It will be tf.float32, as follows:
print x.dtype
tf.float32
Concatenate the two matrices:
x = [[3,6,9], [7,7,7]]
y = [[4,5,6], [5,5,5]]
Concatenate the matrices row-wise:
tf.concat([x, y], 0).numpy()
array([[3, 6, 9], [7, 7, 7], [4, 5, 6], [5, 5, 5]], dtype=int32)
Use the following code to concatenate the matrices column-wise:
tf.concat([x, y], 1).numpy()
array([[3, 6, 9, 4, 5, 6],
[7, 7, 7, 5, 5, 5]], dtype=int32)
Stack the x matrix using the stack function:
tf.stack(x, axis=1).numpy()
array([[3, 7], [6, 7], [9, 7]], dtype=int32)
Now, let' see how to perform the reduce_mean operation:
x = tf.Variable([[1.0, 5.0], [2.0, 3.0]])
x.numpy()
array([[1., 5.], [2., 3.]]
Compute the mean value of x; that is, (1.0 + 5.0 + 2.0 + 3.0) / 4:
tf.reduce_mean(input_tensor=x).numpy()
2.75
Compute the mean across the row; that is, (1.0+5.0)/2, (2.0+3.0)/2:
tf.reduce_mean(input_tensor=x, axis=0).numpy()
array([1.5, 4. ], dtype=float32)
Compute the mean across the column; that is, (1.0+5.0)/2.0, (2.0+3.0)/2.0:
tf.reduce_mean(input_tensor=x, axis=1, keepdims=True).numpy()
array([[3. ], [2.5]], dtype=float32)
Draw random values from the probability distributions:
tf.random.normal(shape=(3,2), mean=10.0, stddev=2.0).numpy()
tf.random.uniform(shape = (3,2), minval=0, maxval=None, dtype=tf.float32,).numpy()
Compute the softmax probabilities:
x = tf.constant([7., 2., 5.])
tf.nn.softmax(x).numpy()
array([0.8756006 , 0.00589975, 0.11849965], dtype=float32)
Now, we'll look at how to compute the gradients.
Define the square function:
def square(x):
return tf.multiply(x, x)
The gradients can be computed for the preceding square function using tf.GradientTape, as follows:
with tf.GradientTape(persistent=True) as tape:
print square(6.).numpy()
36.0
More TensorFlow operations are available in the Notebook on GitHub at http://bit.ly/2YSYbYu.