An Introduction to Tensorflow and Tensors

import datetime
import numpy as np
import tensorflow as tf
print(f'tensorlfow version: {tf.__version__}') # find the version number (should be 2.x+)

# Create a scalar (rank 0 tensor)
scalar = tf.constant(7)
print(f'scalar tensor: {scalar}')
scalar

# Check the number of dimensions of a tensor (ndim stands for number of dimensions)
scalar.ndim

# Create a vector (more than 0 dimensions)
vector = tf.constant([10, 10])
vector

# Check the number of dimensions of our vector tensor
vector.ndim

# Create a matrix (more than 1 dimension)
matrix = tf.constant([[10, 7],
                      [7, 10]])
matrix

matrix.ndim

# Create another matrix and define the datatype
another_matrix = tf.constant([[10., 7.],
                              [3., 2.],
                              [8., 9.]], dtype=tf.float16) # specify the datatype with 'dtype'
another_matrix

# Even though another_matrix contains more numbers than matrix, its 'ndim' (dimension count) is the same:
another_matrix.ndim

# How about a tensor with more than 2 dimensions
tensor = tf.constant([[[1, 2, 3],
                       [4, 5, 6]],
                      [[7, 8, 9],
                       [10, 11, 12]],
                      [[13, 14, 15],
                       [16, 17, 18]]])
tensor

tensor.ndim

# Create a rank 5 (5 dimensions) tensor of 50 numbers between 0 and 100
G = tf.constant(np.random.randint(0, 100, 50), shape=(1, 1, 1, 1, 50))
print(f'G Shape: {G.shape}')
print(f'G Dimension count: {G.ndim}')

# Squeeze tensor G (remove all 1 dimensions)
G_squeezed = tf.squeeze(G)
print(f'SQUEEZED G Shape: {G_squeezed.shape}')
print(f'SQUEEZED G Dimension count: {G_squeezed.ndim}')

# Create the same tensor with tf.Variable() and tf.constant()
changeable_tensor = tf.Variable([10, 7])
unchangeable_tensor = tf.constant([10, 7])
print(changeable_tensor)
print(unchangeable_tensor)

# 
# FAILING at changing a Variable  without ".assign()"
# 
# Will error (requires the .assign() method)
# changeable_tensor[0] = 7
# changeable_tensor

# will return
# TypeError: 'ResourceVariable' object does not support item assignment

# 
# Success changing a tensor
# 
changeable_tensor[0].assign(7)
changeable_tensor

# 
# FAILURE attemtpting to change a constant tensor
# 
# unchangeable_tensor[0].assign(7)
# unchangleable_tensor

# will return
# AttributeError: 'tensorflow.python.framework.ops.EagerTensor' object has no attribute 'assign'

# Create two random (but the same) tensors
random_1 = tf.random.Generator.from_seed(42) # set the seed for reproducibility
random_1 = random_1.normal(shape=(3, 2)) # create tensor from a normal distribution 
random_2 = tf.random.Generator.from_seed(42)
random_2 = random_2.normal(shape=(3, 2))

# Are they equal?
print(random_1)
print(random_2)
print(f'random_1 == random_2: {random_1 == random_2}')

# Create two random (and different) tensors
random_3 = tf.random.Generator.from_seed(42)
random_3 = random_3.normal(shape=(3, 2))
random_4 = tf.random.Generator.from_seed(11)
random_4 = random_4.normal(shape=(3, 2))

# Check the tensors and see if they are equal
# Are they equal?
print(random_3)
print(random_4)
print(f'random_3 == random_4: {random_3 == random_4}')

# Shuffle a tensor (valuable for when you want to shuffle your data)
not_shuffled = tf.constant([[10, 7],
                            [3, 4],
                            [2, 5]])
# Gets different results each time
tf.random.shuffle(not_shuffled)

# Shuffle in the same order every time using the seed parameter (won't acutally be the same)
tf.random.shuffle(not_shuffled, seed=42)

# Shuffle in the same order every time

# Set the global random seed
tf.random.set_seed(42)

# Set the operation random seed
tf.random.shuffle(not_shuffled, seed=42)

# Set the global random seed
tf.random.set_seed(42) # if you comment this out you'll get different results

# Set the operation random seed
tf.random.shuffle(not_shuffled)

# Make a tensor of all ones
print(tf.ones(shape=(3, 2)))

# Make a tensor of all zeros
print(tf.zeros(shape=(3, 2)))

numpy_A = np.arange(1, 25, dtype=np.int32) # create a NumPy array between 1 and 25
A = tf.constant(numpy_A,  
                shape=[2, 4, 3]) # note: the shape total (2*4*3) has to match the number of elements in the array
numpy_A, A

# Create a new tensor with default datatype (float32)
B = tf.constant([1.7, 7.4])

# Create a new tensor with default datatype (int32)
C = tf.constant([1, 7])
print(f'B.dtype: {B.dtype}')
print(f'C.dtype: {C.dtype}')

# Change from float32 to float16 (reduced precision)
B = tf.cast(B, dtype=tf.float16)
print(f'B.dtype: {B.dtype}')

# Change from int32 to float32
C = tf.cast(C, dtype=tf.float32)
print(f'C.dtype: {C.dtype}')

# Create a rank 4 tensor (4 dimensions)
rootDim = 2
nestedOneDim = 3
nestedTwoDim = 4
nestedThreeDim = 5
rank_4_tensor = tf.zeros([rootDim, nestedOneDim, nestedTwoDim, nestedThreeDim])
rank_4_tensor

rank_4_tensor.shape, rank_4_tensor.ndim, tf.size(rank_4_tensor)

# Get various attributes of tensor
print("Datatype of every element:", rank_4_tensor.dtype)
print("Number of dimensions (rank):", rank_4_tensor.ndim)
print("Shape of tensor:", rank_4_tensor.shape)
print("Elements along axis 0 of tensor:", rank_4_tensor.shape[0])
print("Elements along last axis of tensor:", rank_4_tensor.shape[-1])
print("Total number of elements (2*3*4*5):", tf.size(rank_4_tensor).numpy()) # .numpy() converts to NumPy array

# Get the first 2 items of each dimension
rank_4_tensor[:2, :2, :2, :2]

# Get the dimension from each index except for the final one
rank_4_tensor[:1, :1, :1, :]

# Create a rank 2 tensor (2 dimensions)
rank_2_tensor = tf.constant([[10, 7],
                             [3, 4]])

# Get the last item of each row
rank_2_tensor[:, -1]

# Add an extra dimension (to the end)
rank_3_tensor = rank_2_tensor[..., tf.newaxis] # in Python "..." means "all dimensions prior to"
print('---- rank_2_tensor ----')
print(rank_2_tensor)
print('---- rank_3_tensor ----')
print(rank_3_tensor)

# 
# expand_dims
# 
tf.expand_dims(rank_2_tensor, axis=-1) # "-1" means last axis

# You can add values to a tensor using the addition operator
tensor = tf.constant([[10, 7], [3, 4]])
print(tensor + 10)
print(tensor)

print(tensor * 10)

# Use the tensorflow function equivalent of the '*' (multiply) operator
print(tf.multiply(tensor, 10))

tensor - 10