Tensor Transpose in Tensorflow With Example

Tensor transpose is a fundamental operation in TensorFlow that rearranges the dimensions of a tensor according to a specified permutation. This operation is crucial in various machine learning algorithms and data manipulation tasks.

Tensor is useful when dealing with multidimensional data, such as images, time series, and sequences. Transposing a tensor changes the order of its dimensions, providing flexibility in data manipulation and computation.

In this article, we will learn Tensor Transpose in TensorFlow with Example.

Syntax of tf.transpose()

tf.transpose(

a, perm=None, conjugate=False, name='transpose'

)

Parameters

• a: Input tensor.
• perm: Permutation of dimensions. If not provided, the default permutation is set to (n-1...0), where n is the rank of the input tensor.
• conjugate: Optional parameter for complex tensors. The values are conjugated and transposed if set to True and the tensor dtype is either complex64 or complex128.
• name: Optional parameter for operation name.

Transposing a 2D Tensor

Here, we have created a random tensor using NumPy module. We have defined the dimensions of the tensor is 2x3. We use the tf.constant() function to create a constant tensor with the specified values. Then we transposed the 2D tensor using tf.tensor() function. Finally, the original matrix and its transpose are printed. The original matrix represents a 2x3 matrix of random integers, and the transpose operation switches the rows and columns, resulting in a 3x2 matrix.

import numpy as np
import tensorflow as tf

# Define the dimensions of the random matrix
num_rows = 2
num_cols = 3

# Define the range of integers
min_value = 0
max_value = 50  # Adjust as needed

# Generate a tensor
tensor = np.random.randint(min_value, max_value + 1, size=( num_rows, num_cols))
tensor = tf.constant(matrix)
#Transpose the tensor 
transposed_tensor= tf.transpose(tensor)

#print the original matrix and transpose of the matrix 
print("Tensor:")
print(tensor)
print("Transpose of Tensor")
print(transposed_tensor)

Output:

Tensor:
tf.Tensor(
[[[40 41]
  [13  1]]
 [[22 13]
  [ 4  1]]
 [[25 21]
  [35 24]]], shape=(3, 2, 2), dtype=int64)
Transpose of Tensor
tf.Tensor(
[[[40 22 25]
  [13  4 35]]
 [[41 13 21]
  [ 1  1 24]]], shape=(2, 2, 3), dtype=int64)

Transposing a Complex Tensor with Conjugation

Here, we generate a tensor of complex numbers using NumPy and TensorFlow. It defines the dimensions of the tensor, the range of values for the real and imaginary parts, and then creates the complex tensor. After converting it into a TensorFlow constant, the code transposes the tensor while conjugating its elements using TensorFlow's tf.transpose() function with conjugate=True. Finally, it prints both the original tensor and the transposed tensor with conjugation.

import numpy as np

# Define the dimensions of the complex matrix
num_rows = 3
num_cols = 3

#range 
min_val = 0
max_val = 50 

# Generate a tensor of complex numbers 
complex_tensor = np.random.randint(min_val, max_val +1, size=(num_rows, num_cols))+ 1j * np.random.randint(min_val, max_val,size=(num_rows, num_cols))
tensor = tf.constant(complex_tensor)

print("tensor of complex numbers: ")
print(tensor)

# Transpose the tensor with conjugation
transposed_conj_x = tf.transpose(tensor, conjugate=True)
print("Transposed Conjugate tensor:")
print(transposed_conj_x)

Output:

tensor of complex numbers: 
tf.Tensor(
[[15. +9.j 12.+27.j 19.+46.j]
 [45.+48.j 16.+21.j 49.+27.j]
 [12. +5.j  1.+45.j 32.+46.j]], shape=(3, 3), dtype=complex128)
Transposed Conjugate tensor:
tf.Tensor(
[[15. -9.j 45.-48.j 12. -5.j]
 [12.-27.j 16.-21.j  1.-45.j]
 [19.-46.j 49.-27.j 32.-46.j]], shape=(3, 3), dtype=complex128)

Transposing a 3D Tensor

Here, we created a 3D tensor named tensor. We use the tf.constant() function to create a constant tensor with the specified values. The tensor x has a shape of (2, 2, 3), meaning it contains two 2x3 matrices.

Then, we use the tf.transpose() function to transpose the tensor and we use the permutation [0, 2, 1], which means we're swapping the second and third dimensions of the tensor. As a result, the rows and columns within each 2x3 matrix are transposed.

Finally, it prints both the original tensor and its transposed version.

import numpy as np

# Define the dimensions of the 3D tensor
depth = 2
rows = 2
cols = 3

# Define the range of integers
min_value = 0
max_value = 50  # Adjust as needed

# Generate a 3D tensor of random integers
tensor = np.random.randint(min_value, max_value + 1, size=(depth, rows, cols))

# Print the generated 3D tensor
print("Tensor:")
print(tensor)

# Transpose the tensor 
transposed_x = tf.transpose(tensor, perm=[0, 2, 1])
print("Transpose of tensor:")
print(transposed_x.numpy())

Output:

Tensor:
[[[19 39 29]
  [25 14 34]]
 [[ 8 16 31]
  [11 41  6]]]
Transpose of tensor:
[[[19 25]
  [39 14]
  [29 34]]
 [[ 8 11]
  [16 41]
  [31  6]]]

Transposing Tensors with Batch Dimension

Here, we create a tensor with a batch dimension. The tensor contains three 2x2 matrices, representing a batch of data samples. Each 2x2 matrix corresponds to a single data sample.

Then, we use the tf.transpose() function to transpose the tensor and we use the permutation [1, 0, 2], which means we're swapping the first and second dimensions of the tensor. As a result, the batch and feature dimensions are swapped.

import tensorflow as tf

# Define a tensor with a batch dimension
depth = 3
rows = 2
cols = 2
#range
min_value = 0
max_value = 50  # Adjust as needed

# Generate a 3D tensor of random integers
tensor = tf.constant(np.random.randint(min_value, max_value + 1, size=(depth, rows, cols)))

print("tensor:")
print(tensor)

# Transpose the tensor to swap the batch and feature dimensions
transposed_x = tf.transpose(tensor, perm=[1, 0, 2])
print("transpose of tensor:")
print(transposed_x.numpy())

Output:

tensor:
tf.Tensor(
[[[23  8]
  [37 13]]
 [[41 20]
  [37 20]]
 [[48 13]
  [11 37]]], shape=(3, 2, 2), dtype=int64)
transpose of tensor:
[[[23  8]
  [41 20]
  [48 13]]
 [[37 13]
  [37 20]
  [11 37]]]

Transposing a High-dimensional Tensor

Here, we create a 4D tensor named x. The tensor contains two sets of 2x2 matrices, arranged in a 2x2x2x2 structure. This means we have two sets of 2x2 matrices, where each set is arranged along two dimensions.

Then, we use the tf.transpose() function to transpose the tensor and we use the permutation [0, 2, 1, 3], which means we're rearranging the dimensions of the tensor. The first and third dimensions are swapped, and the second dimension remains unchanged.

import tensorflow as tf

# Define a 4D tensor
x = tf.constant([[[[1, 2],
                   [3, 4]],
                  [[5, 6],
                   [7, 8]]],
                 [[[9, 10],
                   [11, 12]],
                  [[13, 14],
                   [15, 16]]]])

# Transpose the tensor to change the order of dimensions
transposed_x = tf.transpose(x, perm=[0, 2, 1, 3])

print("Transposed 4D Tensor:")
print(transposed_x.numpy())

Output:

Transposed 4D Tensor:
[[[[ 1  2]
   [ 5  6]]
  [[ 3  4]
   [ 7  8]]]
 [[[ 9 10]
   [13 14]]
  [[11 12]
   [15 16]]]]

Conclusion

In conclusion, Tensor transpose is a fundamental operation in TensorFlow used for rearranging tensor dimensions. In this article, we learned transposing 2D, complex, 3D, and high-dimensional tensors.