An open-source framework for the Python programming language named PyTorch is crucial in machine-learning duties. The provided order of seq tensors in the given dimension is concatenated using the PyTorch cat function. This masterpiece delves into great detail on the Python PyTorch cat function.

Data is stored in multidimensional arrays called tensors. Therefore, we must import the torch module to use a tensor. tensor() to build a tensor.

The syntax is as follows:

torch.tensor(data)

Where the data in the syntax illustration from the case above refers to an array with several dimensions.

## Cat PyTorch function

The Python Pytorch cat function is covered in this section. The specified order of seq tensors in the given dimension is concatenated using the PyTorch cat function; the tensors must all have the same form.

torch.cat()

Use torch.cat() to combine two or more tensors into a row or column. Thus, to represent the torch.cat(), use the following syntax:

torch.cat((tensor_object1,tensor_object2,………..),dim)

## Exploring the parameters

- Tensors: The tensor is a parameter of any Python sequence of tensors of the same type, and the provided non-empty tensors must all be the same shape except for the cat dimension.
- dim=0: The tensors are concatenated over the dim, which is utilized as a dimension.
- out=None: The default value of out, described as an output tensor, is None.

As its initial parameter, it accepts two or more tensors. The tensors are concatenated column-wise if dim=0. On the other hand, tensors are concatenated row-wise if dim=1.

## Using the cat function in PyTorch

In this section, we will learn how to implement the PyTorch cat function with a Python example. Use the torch to concatenate two or more tensors along the current axis.cat() function.

We shall import the necessary library in the following code, such as import torch.

var_ct = torch.randn(7, 9)

Here, we’re utilizing the torch.randn() function to declare the variable.

var_a=torch.cat((var_ct, var_ct, var_ct), 0)

Here, the torch.cat() function is being called. The print() method is primarily responsible for printing the value of the variable var_a. The complete representation of this concept is as follows:

#begin by importing the library: torch import torch # Declaring the variable var_ct = torch.randn(7, 9) print(var_ct) # initiating the function, cat() var_a=torch.cat((var_ct, var_ct, var_ct), 0) var_b=torch.cat((var_ct, var_ct, var_ct), 1) # Print the output print(var_a) print(var_b)

### Multiple Sequences of Tensors Concatenated

This example demonstrates combining four distinct tensors into one tensor using cat(). The PyTorch library is first imported, then the desired tensor sequences are created using the tensor function.

var_t1 = torch.tensor([1,2,3,4]) var_t2 = torch.tensor([5,6,7,8]) var_t3 = torch.tensor([9,10,11,12]) var_t4 = torch.tensor([13,14,15,16])

We now combine them, and as we can see, the four distinct tensors have been combined to create a single tensor along axis 0, the only available one.

torch.cat( (var_t1,var_t2,var_t3,var_t4) ,dim=0 )

### PyTorch cat function using dimension as 0

This part teaches us how to use Python’s PyTorch cat function with a dimension set to 0. Here, we’re utilizing the torch.cat() method joins two or more tensors together by concatenating them column-wise with a dimension of 0.

# library importation import torch # variable declaration var_1_c = torch.tensor([2,4,6,8]) var_2_c = torch.tensor([3,6,9,12]) var_3_c = torch.tensor([4,8,12,16]) var_4_c = torch.tensor([5,10,15,20]) # view the tensors we've created above print("var 1:\n", var_1_c) print("var 2:\n", var_2_c) print("var 3:\n", var_3_c) print("var 4:\n", var_4_c) # Calling the torch.cat() function var_c=torch.cat( (var_1_c,var_2_c,var_3_c,var_4_c) ,dim=0 ) # showing the output print(var_c)

### How to use the Python cat function with the dimension set to -1

This section will discover how to use Python’s PyTorch cat function with a dimension set to -1. Here, we’re utilizing the torch.cat() method uses dim as -1 to concatenate two or more tensors row-wise.

# begin by importing the library- torch import torch # Tensor's declaration var_1_tens = torch.Tensor([[12, 13, 14], [15, 16, 17]]) var_2_tens = torch.Tensor([[18,19, 20], [21, 22, 23]]) # print first tensors print("Tensor One: \n", var_1_tens) # print second tensor print("Tensor Two \n", var_2_tens ) # Calling the torch.cat() function and join tensor in -1 dimension var_tensor = torch.cat((var_1_tens, var_2_tens), -1) print("Tensors concatenation in the -1 dimension \n", var_tensor)

### Concatenate (3D tensor) along the 0 and -1 dimensions in PyTorch

This part teaches us how to concatenate along 0 and -1 dimensions in Python and about the PyTorch 3D tensor. In this case, we’re utilizing the torch.cat() method joins two or more tensors row- and column-wise using the dimensions 0 and -1.

# begin by importing the required library import torch # tensors' creation var_1_c = torch.Tensor([[2,4],[3,6]]) var_2_c = torch.Tensor([[4,8],[5,10]]) var_3_c = torch.Tensor([[6,12],[7,14]]) # print above created tensors print("var 1:\n", var_1_c) print("var 2:\n", var_2_c) print("var 3:\n", var_3_c ) # viewing the tensor in the dimension 0 print("Concatenation of the tensors in the dimensions 0") # Calling of the torch.cat() function var_c = torch.cat((var_1_c, var_2_c, var_3_c ), 0) print("c:\n", var_c) print("Concatenate the tensors in the -1 dimension") var_c = torch.cat((var_1_c ,var_2_c ,var_3_c ), -1) print("c:\n", var_c)

### Example: Generate two one-dimensional tensors

In this example, the torch will generate two one-dimensional tensors and concatenate via rows.cat()

#importation of the torch module import torch # start by creating two tensors initially var_one_data = torch.tensor([10,20,30,40,50]) var_two_data = torch.tensor([1,2,3,4,5]) print("Show the real Tensors: ") print(var_one_data) print(var_two_data) #Concatenation of the two tensors print("Tensor concatenation: ",torch.cat((var_one_data,var_two_data)))

Since the tensors are of type 1 dimensional, they are concatenated horizontally (row-wise).

### Example : Generate four one-dimensional tensors

Here, we’ll use torch.cat() to generate four one-dimensional tensors and concatenate them row-wise.

#start by importing the torch module import torch #create four tensors var_one_data = torch.tensor([10,20,40,50]) var_two_data = torch.tensor([12,45,67,89]) var_three_data = torch.tensor([100,32,45,67]) var_four_data = torch.tensor([120,456,1,1]) #display print("Actual Tensors: ") print(var_one_data ) print(var_two_data) print(var_three_data) print(var_four_data) #concatenation of two tensors print("Concatenation of the Tensor: ",torch.cat((var_one_data,var_two_data,var_three_data,var_four_data)))

Since the tensors are of type 1 dimensional, five are concatenated horizontally (row-wise).

### Example: Generate five two-dimensional tensors

In this example, we’ll use torch.cat() to generate five two-dimensional tensors and concatenate them in rows.

#begin by importing the torch module import torch #creation of tensors with the two Dimensions each var_one_data = torch.tensor([[10,20,40,50],[1,2,3,4]]) var_two_data = torch.tensor([[2,3,4,5],[20,70,89,0]]) var_three_data = torch.tensor([[12,4,5,6],[56,34,56,787]]) var_four_data = torch.tensor([[100,1,2,3],[67,87,6,78]]) var_five_data = torch.tensor([[120,33,56,78],[45,56,78,6]]) print("The actual tensors: ") print(var_one_data) print(var_two_data) print(var_three_data) print(var_four_data) print(var_five_data) #Concatenation of the tensors via rows print("Concatenation of the Tensor: ",torch.cat((var_one_data,var_two_data,var_three_data,var_four_data,var_five_data),dim=1))

As we specified dim=1, five tensors are concatenated horizontally (row-wise).

### Example: Generate five two-dimensional tensors

In this example, we’ll use torch.cat() to generate five two-dimensional tensors and concatenate them through columns.

# begin by importing the torch module import torch #creation of five tensors with 2 Dimensions each var_one_data = torch.tensor([[10,20,40,50],[1,2,3,4]]) var_two_data = torch.tensor([[2,3,4,5],[20,70,89,0]]) var_three_data = torch.tensor([[12,4,5,6],[56,34,56,787]]) var_four_data = torch.tensor([[100,1,2,3],[67,87,6,78]]) var_five_data = torch.tensor([[120,33,56,78],[45,56,78,6]]) print("Actual Tensors: ") print(var_one_data) print(var_two_data) print(var_three_data) print(var_four_data) print(var_five_data) #The Concatenation of the tensors through columns print("Resultant Tensor concatenated: ",torch.cat((var_one_data,var_two_data,var_three_data,var_four_data,var_five_data),dim=0))

As we supplied dim=0, five tensors are concatenated vertically (column-wise).

### Utilize a CPU

We must develop a tensor with a cpu() function if we want to execute a cat() function on the CPU. It will operate on a computer with a CPU. Further, we can now use the cpu() method to create a tensor. The syntax is as follows:

torch.tensor(data).cpu()

#### Example: Generate two one-dimensional tensors

In this demonstration, two one-dimensional tensors will be generated on the CPU and then concatenated via rows using the torch.cat().

#starting the import torch module import torch #creation of two tensors var_one_data = torch.tensor([10,20,30,40,50]).cpu() var_two_data = torch.tensor([1,2,3,4,5]).cpu() print("The real Tensors: ") print(var_one_data) print(var_two_data) #Concatenation of the two tensors created above print("Concatenating the Tensor: ",torch.cat((var_one_data,var_two_data)))

Since the tensors are type 1, they are concatenated horizontally (row-wise).

#### Example: use the torch.cat() to concatenate five one-dimensional tensors

In this demonstration, we’ll use the torch.cat() to concatenate five one-dimensional tensors row-wise on the CPU.

#start by importing the torch module import torch #creation of five new tensors var_one_data = torch.tensor([10,20,40,50]).cpu() var_two_data = torch.tensor([2,3,4,5]).cpu() var_three_data = torch.tensor([12,45,67,89]).cpu() var_four_data = torch.tensor([100,32,45,67]).cpu() var_five_data = torch.tensor([120,456,1,1]).cpu() print("Actual Tensors: ") print(var_one_data) print(var_two_data) print(var_three_data) print(var_four_data) print(var_five_data) #concatenation of the two tensors print("Resultant concatenated Tensor: ",torch.cat((var_one_data,var_two_data,var_three_data,var_four_data,var_five_data)))

Since the tensors are of type 1 dimensional, five tensors are concatenated horizontally (row-wise).

#### Example: use the torch.cat() to concatenate five two-dimensional tensors

In this demonstration, we’ll use the torch.cat() to concatenate five two-dimensional tensors created on the CPU using rows.

#start by importing the torch module import torch #creating five tensors whose individual dimensions are 2 var_one_data = torch.tensor([[10,20,40,50],[1,2,3,4]]).cpu() var_two_data = torch.tensor([[2,3,4,5],[20,70,89,0]]).cpu() var_three_data = torch.tensor([[12,4,5,6],[56,34,56,787]]).cpu() var_four_data = torch.tensor([[100,1,2,3],[67,87,6,78]]).cpu() var_five_data = torch.tensor([[120,33,56,78],[45,56,78,6]]).cpu() #display print("Actual Tensors: ") print(var_one_data) print(var_two_data) print(var_three_data) print(var_four_data) print(var_five_data) #using rows to concatenate tensors print("Concatenated Tensor: ",torch.cat((var_one_data,var_two_data,var_three_data,var_four_data,var_five_data),dim=1))

As we specified dim=1, five tensors are concatenated horizontally (row0-wise).

#### Example: use the CPU to produce five two-dimensional tensors

In this demonstration, we’ll use the CPU to produce five two-dimensional tensors using the torch.cat() to concatenate them via columns.

#start by importing the torch module import torch #creation of five tensors with 2 Dimensions each var_one_data = torch.tensor([[10,20,40,50],[1,2,3,4]]).cpu() var_two_data = torch.tensor([[2,3,4,5],[20,70,89,0]]).cpu() var_three_data = torch.tensor([[12,4,5,6],[56,34,56,787]]).cpu() var_four_data = torch.tensor([[100,1,2,3],[67,87,6,78]]).cpu() var_five_data = torch.tensor([[120,33,56,78],[45,56,78,6]]).cpu() print("The real tensors: ") print(var_one_data) print(var_two_data) print(var_three_data) print(var_four_data) print(var_five_data) #Using columns in concatenation of the tensors print("Concatenated Tensor: ",torch.cat((var_one_data,var_two_data,var_three_data,var_four_data,var_five_data),dim=0))

As we supplied dim=0, five tensors are concatenated vertically (column-wise).

## Conclusion

We explored using PyTorch’s cat() function to concatenate two or more tensors both horizontally and vertically in this piece. Tensors are concatenated row-wise if dim=1 and column-wise if dim=0, respectively. Additionally, we implemented various examples to concatenate one and two-dimensional tensors in this post, as well as cat() on the CPU using the cpu() function.

A series of tensors in the same dimension can be concatenated using PyTorch’s Cat() function. To prevent empty tensors on non-concatenating dimensions, we must ensure that the tensors used for concatenating have the same shape. Also, note that the cat() function closely resembles the stack() function. Further, tensors are concatenated along an existing axis in the concat() method, but a new axis (that is non-existent for each tensor) is created in the stack() function.