Welcome to the fascinating realm of artificial intelligence powered by TensorFlow. The future of machine learning is built upon this cutting-edge technological marvel. Let’s dive into the core concept. TensorFlow was crafted by the tech giant, Google, to elevate machine learning applications to the next level with simplicity and effectiveness.
Usually, TensorFlow goes by the abbreviation ‘tf.’ TensorFlow operates based on the concept of tensors, which are 3-dimensional arrays. Visualizing tensors as cuboids with length, width, and depth helps us handle them effectively for our analytical needs. Tensors also make analytical tasks easier compared to older methods.
In this article, I’m going to be your guide from the very basics. We’ll start by unraveling the mystery behind tensors and gradually lead you toward harnessing TensorFlow’s incredible potential effectively. Whether you’re a complete beginner or looking to expand your machine learning skills, this comprehensive guide will equip you with the knowledge and tools you need to excel in the world of TensorFlow. So, let’s embark on this exciting journey together and unlock the mystery behind the word “tf”.
import tensorflow as tf
Creating tensors using tf.constant(), tf.Variable(), or by converting NumPy arrays to tensors using tf.convert_to_tensor().
# Create a tensor with a constant value
tensor1 = tf.constant(3.0) # A scalar tensor
tensor2 = tf.constant([1, 2, 3, 4, 5]) # A 1D tensor
tensor3 = tf.constant([[1, 2], [3, 4]]) # A 2D tensor# Creating a new variable tensor
variable_tensor = tf.Variable([1.0, 2.0, 3.0])
# Changing the value of a already defined variable tensor
variable_tensor.assign([4.0, 5.0, 6.0])
# Here I need to import NumPy library to create an array.
# Then I will convert NumPy arrays as tensor.import numpy as np
numpy_array = np.array([1, 2, 3, 4, 5])
# Convert a NumPy array to a tensor
tensor_from_numpy = tf.convert_to_tensor(numpy_array)
Here, we also can create tensor (2D arrays) with zeros or ones.
# Create tensors filled with ones and zeros
ones_tensor = tf.ones([3, 3]) # A 3x3 tensor filled with ones
zeros_tensor = tf.zeros([2, 4]) # A 2x4 tensor filled with zeros
TensorFlow provides various functions to create tensors filled with random values. Some common ones include tf.random.normal (generates values from a normal distribution), tf.random.uniform (generates values from a uniform distribution), and tf.random.shuffle (shuffles the elements of a tensor randomly). These functions allow you to control the distribution and shape of the random tensor you want to create.
# Random values between 0 and 1 >> Here dimension is 2x3
random_uniform_tensor = tf.random.uniform([2, 3], minval=0, maxval=1) # Random values from a normal distribution >> Here dimension is 3x2
random_normal_tensor = tf.random.normal([3, 2], mean=0.0, stddev=1.0)
TensorFlow supports a wide range of operations that you can perform on tensors. Here’s a list of common operations along with code examples:
General Operations
Assume that following operations are done over predefined tensors; ‘tensor1’, ‘tensor2’, ‘tensor’, ‘matrix1’, ‘matrix2’ and ‘matrix’.
# Addition
result = tf.add(tensor1, tensor2)# Substraction
result = tf.subtract(tensor1, tensor2)
# Multiplication
result = tf.multiply(tensor1, tensor2)
# Division
result = tf.divide(tensor1, tensor2)
# Element-wise sqaure
result = tf.square(tensor)
# Matrix multiplication
result = tf.matmul(matrix1, matrix2)
# Matrix transposition
transposed_matrix = tf.transpose(matrix)
Reduction Operations
# Sum across axes# Sum of elements across rows
sum_across_rows = tf.reduce_sum(matrix, axis=0)
# Sum of elements across columns
sum_across_columns = tf.reduce_sum(matrix, axis=1)
# Mean Calculation
mean = tf.reduce_mean(matrix)
# Maximum calculation
max_value = tf.reduce_max(matrix)# Minimum calculation
min_value = tf.reduce_min(matrix)
Reshaping and Slicing
# Reshape Tensor
reshaped_tensor = tf.reshape(tensor, shape)# Slice Tensor
sliced_tensor = tensor[start:end]
>>> Example:
import tensorflow as tf# Create a 1D tensor
original_tensor = tf.constant([1, 2, 3, 4, 5, 6])
# Reshape the tensor into a 2D tensor (3 rows and 2 columns)
reshaped_tensor = tf.reshape(original_tensor, (3, 2))
print("Original Tensor:")
print(original_tensor)
print("\nReshaped Tensor:")
print(reshaped_tensor)
>>> Expected outputOriginal Tensor:
[1 2 3 4 5 6]
Reshaped Tensor:
[[1 2]
[3 4]
[5 6]]
import tensorflow as tf# Create a 2D tensor
matrix = tf.constant([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
# Slice a portion of the tensor (rows 1 to 2, columns 0 to 2)
sliced_tensor = matrix[1:3, 0:3]
print("Original Tensor:")
print(matrix)
print("\nSliced Tensor:")
print(sliced_tensor)
>>> Expected outputOriginal Tensor:
[[1 2 3]
[4 5 6]
[7 8 9]]
Sliced Tensor:
[[4 5 6]
[7 8 9]]
Math Functions
# Exponential Function
exp_result = tf.exp(tensor)# Square root
sqrt_result = tf.sqrt(tensor)
# Logarithm
log_result = tf.math.log(tensor)
>>> Example (Exponential Function):>>>
import tensorflow as tf# Create a tensor
tensor = tf.constant([1.0, 2.0, 3.0, 4.0])
# Compute the element-wise exponential
exp_result = tf.exp(tensor)
print("Original Tensor:")
print(tensor)
print("\nExponential Result:")
print(exp_result)
>>> Expected output
Original Tensor:
[1. 2. 3. 4.]
Exponential Result:
[ 2.7182817 7.389056 20.085537 54.59815 ]
>>> Example (Square root):
import tensorflow as tf# Create a tensor
tensor = tf.constant([1.0, 4.0, 9.0, 16.0])
# Compute the element-wise square root
sqrt_result = tf.sqrt(tensor)
print("Original Tensor:")
print(tensor)
print("\nSquare Root Result:")
print(sqrt_result)
>>> Expected outputOriginal Tensor:
[ 1. 4. 9. 16.]
Square Root Result:
[1. 2. 3. 4.]
>>> Example (Logarithm):
import tensorflow as tf# Create a tensor
tensor = tf.constant([1.0, 2.0, 4.0, 8.0])
# Compute the element-wise natural logarithm
log_result = tf.math.log(tensor)
print("Original Tensor:")
print(tensor)
print("\nLogarithm Result:")
print(log_result)
>>> Expected outputOriginal Tensor:
[1. 2. 4. 8.]
Logarithm Result:
[0. 0.6931472 1.3862944 2.0794415]
Comparison Operations
# Element-wise Comparison
comparison_result = tf.equal(tensor1, tensor2)# Finding Maximum and Minimum Values
max_value = tf.argmax(tensor)
min_value = tf.argmin(tensor)
>>> Example (Element-wise Comparison):
import tensorflow as tf# Create two tensors
tensor1 = tf.constant([1, 2, 3, 4])
tensor2 = tf.constant([2, 2, 3, 3])
# Perform element-wise comparison
comparison_result = tf.equal(tensor1, tensor2)
print("Tensor 1:")
print(tensor1)
print("\nTensor 2:")
print(tensor2)
print("\nComparison Result:")
print(comparison_result)
>>> Expected outputTensor 1:
[1 2 3 4]
Tensor 2:
[2 2 3 3]
Comparison Result:
[False True True False]
>>> Example (Finding Maximum and Minimum Values):
import tensorflow as tf# Creating a tensor
tensor = tf.constant([3, 1, 4, 1, 5, 9, 2, 6, 5, 3])
# Finding the maximum value's index
max_index = tf.argmax(tensor)
# Finding the minimum value's index
min_index = tf.argmin(tensor)
print("Tensor:")
print(tensor)
print("\nIndex of Maximum Value:", max_index.numpy())
print("Index of Minimum Value:", min_index.numpy())
>>> Expected outputTensor:
[3 1 4 1 5 9 2 6 5 3]
Index of Maximum Value: 5
Index of Minimum Value: 1
Advanced Math Operations
# Trigonometric Functions
sine = tf.sin(angles)
cosine = tf.cos(angles)# Hyperbolic Functions
sinh = tf.sinh(values)
cosh = tf.cosh(values)
>>> Example (Trigonometric Functions):
import tensorflow as tf# Create a tensor of angles in radians
angles = tf.constant([0.0, tf.math.pi / 4, tf.math.pi / 2])
# Compute sine and cosine of the angles
sine = tf.sin(angles)
cosine = tf.cos(angles)
print("Angles (radians):", angles.numpy())
print("Sine:", sine.numpy())
print("Cosine:", cosine.numpy())
>>> Expected Output:Angles (radians): [0. 0.7853982 1.5707964]
Sine: [0. 0.70710677 1. ]
Cosine: [1.000000e+00 7.071067e-01 6.123234e-17]
>>> Example (Hyperbolic Functions):
import tensorflow as tf# Create a tensor
values = tf.constant([0.0, 1.0, 2.0])
# Compute hyperbolic sine and cosine
sinh = tf.sinh(values)
cosh = tf.cosh(values)
print("Values:", values.numpy())
print("Hyperbolic Sine:", sinh.numpy())
print("Hyperbolic Cosine:", cosh.numpy())
>>> Expected Output:Values: [0. 1. 2.]
Hyperbolic Sine: [ 0. 1.1752012 3.6268604 ]
Hyperbolic Cosine: [1. 1.5430806 3.7621956 ]
In this example, tf.argmax() and tf.argmin() are used to find the indices of the maximum and minimum values in the input tensor, respectively.
Be the first to comment