# Creating a Tensor in Pytorch

## What is Pytorch?

Pytorch is a Python - based framework in machine learning primarily used for scientific computations and to build deep learning models.

A Tensor is a popular concept in Machine learning and Data science. Tensors are a generalized term for matrices and vectors. In simple words, Tensors can be anything - a n-dimensional array, a vector, or a matrix. In this article, we will be looking at the multiple methods used to create Tensors in Pytorch.

## Method of Creating Tensors

Tensors can be created in multiple methods. Some of the important methods are listed below.

• Creating a tensor using ones

• Creating a tensor using zeros

• Creating a tensor using arange

• Creating a tensor using rand()

• Creating a tensor using full()

• Creating a tensor using linspace

• Creating a tensor using randint()

• Creating a tensor using the eye() method

• Creating a tensor using the tensor method

• creating a tensor using complex method

As an initial step, we must import the torch first before getting to the different methods of creating Tensors.

### Syntax

#importing torch
import torch


## Approach 1: Creating a tensor using ones()

Using the ones() function, the tensor is created such that all its elements are set to 1.

Let us write a code in Python programming to create a tensor using ones() function.

### Example

#creating a tensor using ones()
tensor_using_ones = torch.ones(4,4,5)
#prints the created tensor
print(tensor_using_ones)


### Output

We can see from the below output that the newly created tensor has all entries set to “1” in the shape (4,4,5).

tensor([[[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]],

[[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]],

[[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]],

[[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]]])


## Approach 2: Creating a tensor using zeros()

We use the zeros() function to create a tensor which has all its elements set to 0. Using this, the values can be passed either as a list, a tuple or empty values. Tensors can be created in any of these ways.

Using the zeros() function, the tensor is created such that all its elements are set to 0.

### Example

#creating a tensor using zeros()
tensor_using_zeros = torch.zeros(4,4,5)
#prints the created tensor
print(tensor_using_zeros)


### Output

We can see from the below output that the newly created tensor has all entries set to “0” in the shape (4,4,5).

tensor([[[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.]],

[[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.]],

[[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.]],

[[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.]]])


## Approach 3: Creating a tensor using arange() – Example 1

The arange() function is used to create a 1-dimensional (1D) tensor.

### Syntax

The arange() function has the following syntax.

torch.arange(start,end,step-size)


where,

start - is inclusive

end - is exclusive of the specified shape

We write a code in Python to create a 1-D tensor with the shape specifications (5,30,2).

### Example

#creating a tensor using arange
tensor_using_arange = torch.arange(5, 30,2)
#prints the created tensor
print(tensor_using_arange)


### Output

Here, a 1-dimensional tensor is created with the initial element as 5, ending element as 29 (i.e 30-1) with a common difference (step) of ”2”.

tensor([ 5,  7,  9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29])


## Approach 4: Creating a tensor using arange() - Example 2

Let us look at another example of creating a tensor in Pytorch where the start value is negative i.e -5 and a step of “1”.

We write a code in python to create a 1-D tensor with the shape specifications (-5,25,1).

### Example

#creating a tensor using arange
tensor_using_arange1 = torch.arange(-5, 25,1)
#prints the created tensor
print(tensor_using_arange1)


### Output

Here, a 1-dimensional tensor is created with the initial element as -5, ending element as 24 (i.e 25-1) with a common difference (step) of ”1”.

tensor([-5, -4, -3, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24])


## Approach 5: Creating a tensor using rand()

Another commonly used method to create a Tensor in Python is the rand() method. A Tensor containing random numbers will be created using the rand() method for the specified shape.

### Syntax

The syntax of the rand() method is shown below −

torch.rand(shape)


### Example

Now to understand the creation of a Tensor using the rand() method, let's write a code in Python programming.

#creating a tensor using rand()
tensor_using_rand = torch.rand(5, 5)
#prints the created tensor
print(tensor_using_rand)


### Output

We can see from the below output, a Tensor of shape 5X5 is created using the rand() method. The elements inside the tensor are random numbers of the Uniform distribution.

tensor(
[[0.2000, 0.6068, 0.3968, 0.6269, 0.8587],
[0.1754, 0.5050, 0.8569, 0.5139, 0.9026],
[0.2634, 0.6543, 0.3015, 0.6873, 0.2214],
[0.9257, 0.6045, 0.4763, 0.5107, 0.7925],
[0.7465, 0.0279, 0.4937, 0.0989, 0.8806]])


## Approach 6: Creating a tensor using full()

The full() method in Tensor is used whenever the elements in a Tensor are preferred to be the same number.

### Syntax

The syntax for the full() method is as follows.

torch.full(size, fill_value, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)


where,

fill_value - is the value (same number) which we want to be in the Tensor.

Suppose, if we want to create a Tensor having the same number (4) as all the elements. We can write the code in Python programming as shown below. The fill_value is specified as 4. That is the value that will be the common element in the Tensor.

### Example

#creating a tensor using full method
tensor1 = torch.full((5,5,4)
#prints the created tensor
print(tensor1)


### Output

For the above code, we give a Tensor with 5X5 matrix with 4 as all elements.

tensor([[4, 4, 4, 4, 4],
[4, 4, 4, 4, 4],
[4, 4, 4, 4, 4],
[4, 4, 4, 4, 4],
[4, 4, 4, 4, 4]])


## Approach 7: Creating a tensor using linspace

### Syntax

Linspace() method has the following syntax.

linspace (start, stop, num, endpoint=True, retstep=False, dtype=None, axis=0)


where,

low - starting element(inclusive)

high- ending element(inclusive)

num- number of elements to be generated in the Tensor

### Example

We use the Linspace () method to create a 1- dimensional (1D) tensor. The shape we specify for example, in this case is (2,20,4). In our example, 2 is the starting element, 20 is the ending element and 4 is the number of the elements to be present in the 1-D Tensor.

#creating a tensor using linspace
tensor_using_linspace = torch.linspace(2, 20, 4)
#prints the created tensor
print(tensor_using_linspace)


### Output

We can see that the above code yields the output below where a 1-D Tensor is created with 4 elements.

tensor([ 2.,  8., 14., 20.])


## Approach 8: Creating a tensor using randint()

The randint() method creates a Tensor with random integers generated according to the specified shape.

### Syntax

torch.randint(low,high,shape)


where,

low - starting element(inclusive)

high- ending element(exclusive)

shape - shape of the Tensor

### Example

We write a Python code using the randint() methods as shown below.

#creating a tensor using randint
tensor_using_randint = torch.randint(10,100, (2,2))
#prints the created tensor
print(tensor_using_randint)


### Output

In the below output, we see a Tensor with random elements generated between the shape (10,100,(5,5)). Here, we get a Tensor with random elements between 10 and 99 in the shape of a 5X5 matrix.

tensor([[71, 32, 56, 34, 21],
[37, 71, 98, 63, 40],
[41, 45, 27, 41, 50],
[51, 42, 43, 71, 14],
[87, 52, 77, 88, 85]])


## Approach 9: Creating a tensor using eye()

The eye() method is useful when we want to create a 2D Tensor where the elements in the diagonal are 1 and zeros as the rest of the elements.

### Syntax

torch.eye (shape)


Now, we write a Python code using the eye() method.

### Example -1

#creating a tensor using eye
tensor1_using_eye = torch.eye(4, 4)
#prints the created tensor
print(tensor1_using_eye)


### Output

We have now created a 2D 4X4 Tensor using the eye() method.

tensor([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])


Lets see another example of creating a tensor using the eye function.

### Example-2

#creating a tensor using eye
tensor2_using_eye = torch.eye(3)
#prints the created tensor
print(tensor2_using_eye)


### Output

We have now created a 2D 3X3 Tensor using the eye() method as shown in the below output.

tensor([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])


## Approach 10: Creating a tensor using Complex() method

The complex () method is the last method we are going to look at. It is used to create a Complex Tensor where the created Tensor will have both imaginary part and real part.

### Syntax

The complex() method has the following syntax.

torch.complex(real part, imaginary part)


### Example

The code for the complex() method is written below.

real_tensor = torch.rand(4,5)
print(real_tensor)
imaginary_tensor = torch.rand(4, 5)
print(imaginary_tensor)
tensor_using_complex = torch.complex(real_tensor, imaginary_tensor)
#prints created tensor
print(tensor_using_complex )


### Output

Thus, we have created a complex Tensor having the imaginary part and real part of shape 4X5.

Tensor([[0.8284, 0.7833, 0.4952, 0.7634, 0.9098],
[0.6373, 0.3428, 0.0352, 0.6095, 0.8066],
[0.7292, 0.0703, 0.3846, 0.6653, 0.1924],
[0.2920, 0.2676, 0.4669, 0.2841, 0.5974]])
tensor([[0.5236, 0.9037, 0.7622, 0.7044, 0.3362],
[0.8543, 0.6088, 0.4882, 0.0563, 0.9318],
[0.7075, 0.1176, 0.6272, 0.3318, 0.3751],
[0.6317, 0.1482, 0.3772, 0.6941, 0.9126]])
tensor([[0.8284+0.5236j, 0.7833+0.9037j, 0.4952+0.7622j, 0.7634+0.7044j, 0.9098+0.3362j],
[0.6373+0.8543j, 0.3428+0.6088j, 0.0352+0.4882j, 0.6095+0.0563j, 0.8066+0.9318j],
[0.7292+0.7075j, 0.0703+0.1176j, 0.3846+0.6272j, 0.6653+0.3318j, 0.1924+0.3751j],
[0.2920+0.6317j, 0.2676+0.1482j, 0.4669+0.3772j, 0.2841+0.6941j, 0.5974+0.9126j]])


## Conclusion

From this article, we have learnt multiple ways to create tensors in Pytorch. We recommend you to take a look at our articles as well.

Updated on: 02-May-2023

118 Views

##### Kickstart Your Career

Get certified by completing the course

Advertisements