Introduction to PyTorch Tensors with torch.Tensor

Introduction to PyTorch Tensors with torch.Tensor

Creating and Initializing Tensors

Tensors are a central aspect of PyTorch and are used to encode the inputs and outputs of a model, as well as the model’s parameters. In PyTorch, we use the torch.Tensor class to create tensors, which are multi-dimensional arrays similar to NumPy arrays. However, unlike NumPy, PyTorch tensors can utilize GPUs to accelerate their numeric computations.

To start working with tensors in PyTorch, we must understand how to create and initialize them. There are several ways to create tensors in PyTorch:

  • Directly from data
# Create a tensor directly from a list or a numpy array
data = [[1, 2], [3, 4]]
x_data = torch.tensor(data)
  • From another tensor
# Create a tensor with the same shape and type as another tensor, but with random values
x_ones = torch.ones_like(x_data)
x_rand = torch.rand_like(x_data, dtype=torch.float)
  • With random or constant values
# Create a tensor filled with random values
shape = (2, 3,)
rand_tensor = torch.rand(shape)

# Create a tensor filled with ones
ones_tensor = torch.ones(shape)

# Create a tensor filled with zeros
zeros_tensor = torch.zeros(shape)

Once a tensor is created, you can also modify its type (or dtype) and where it’s stored (CPU or GPU):

# Cast a tensor to a different type
float_tensor = torch.randn((2, 2)).to(torch.float32)

# Move your tensor to the GPU if available
if torch.cuda.is_available():
    tensor ='cuda')

It is important to note the difference between torch.Tensor and torch.tensor. The torch.Tensor constructor gives you more control over the tensor’s data type and initial values. It defaults to creating floating-point tensors. In contrast, torch.tensor infers the dtype from the input data.

Understanding how to create and initialize tensors is the first step in using the full potential of PyTorch for building machine learning models.

Manipulating Tensors with Basic Operations

Once you have created and initialized your tensors, the next step is to manipulate them using basic operations. PyTorch provides a comprehensive set of operations that you can perform on tensors, including arithmetic, indexing, reshaping, and more.

Arithmetic Operations:

Basic arithmetic operations such as addition, subtraction, multiplication, and division can be performed on tensors. PyTorch overloads the standard arithmetic operators to make these operations intuitive.

# Addition
result = tensor + other_tensor

# Subtraction
result = tensor - other_tensor

# Element-wise multiplication
result = tensor * other_tensor

# Element-wise division
result = tensor / other_tensor

PyTorch also includes functions for these operations, which can be useful when you need to specify additional parameters:

# Addition with a scalar
result = torch.add(tensor, 10)

# In-place addition (modifies tensor)

Indexing and Slicing:

Indexing and slicing tensors in PyTorch is similar to indexing and slicing NumPy arrays. You can use standard Python indexing syntax to access elements or subarrays:

# Get the first row
first_row = tensor[0]

# Slice a 2x2 block from the tensor
block = tensor[1:3, 1:3]

# Select elements using a boolean mask
selected_elements = tensor[tensor > 0]

Reshaping Tensors:

Reshaping a tensor is often necessary when working with neural networks. The view and reshape functions are used to change the shape of a tensor without modifying its data.

# Reshape a 4x4 tensor into a 2x8 tensor
reshaped_tensor = tensor.view(2, 8)

# Flatten the tensor to a 1D array
flattened_tensor = tensor.view(-1)

Note that view requires the new shape to be compatible with the original shape.


Broadcasting is a feature that allows PyTorch to perform operations on tensors of different shapes. When you perform an operation between tensors with different shapes, PyTorch automatically expands one or both tensors to have compatible shapes.

# Add a scalar to a tensor (broadcasting)
result = tensor + 10

# Add two tensors of different shapes (broadcasting)
tensor_1d = torch.tensor([1, 2, 3])
expanded_tensor = tensor_1d.view(-1, 1) + tensor

Understanding how to manipulate tensors is important for developing complex neural network architectures. By mastering these basic operations, you will be well-equipped to tackle more advanced tasks in PyTorch.

Advanced Tensor Operations and Functionality

When we dive deeper into PyTorch’s capabilities, we find various advanced tensor operations that help us to build and train complex models. These encompass linear algebra operations, tensor concatenation, broadcasting with more than two tensors, and applying user-defined functions. Let’s explore some of these functionalities:

Linear Algebra Operations:

PyTorch is features an rich set of functions for performing linear algebra operations which are essential for neural network computations.

# Matrix multiplication
result = torch.matmul(tensor, other_tensor)

# Dot product
result =, vector2)

# Eigenvalues and eigenvectors
eigenvalues, eigenvectors = torch.eig(matrix, eigenvectors=True)

Tensor Concatenation:

Concatenation is a common operation for combining tensors along a specific dimension. The function is commonly used for this purpose.

# Concatenate along the 0th dimension (vertical)
concatenated_tensor =[tensor1, tensor2], dim=0)

# Concatenate along the 1st dimension (horizontal)
concatenated_tensor =[tensor1, tensor2], dim=1)

Broadcasting with Multiple Tensors:

Broadcasting can extend beyond simple operations and scalar values. PyTorch allows broadcasting operations across multiple tensors with varying shapes, provided they meet certain conditions.

# Broadcasting with multiple tensors
tensor3 = torch.randn((5, 5))
result = tensor1 * tensor2 * tensor3

If tensors are not compatible for broadcasting, an error will be raised indicating that shapes cannot be broadcast together.

User-defined Functions:

Sometimes predefined functions do not meet our specific requirements. We can define our own functions which can be applied element-wise or as reductions on tensors.

# User-defined function applied to each element
def custom_function(x):
    return x**2 + 2*x + 1

result_tensor = torch.tensor([1, 2, 3])
result = custom_function(result_tensor)

Advanced operations further bring automatization, such as gradient calculations with torch.autograd, which is pivotal for training neural networks through backpropagation.

# Enable gradient tracking

# Perform operations
y = tensor * tensor * 3
z = y.mean()

# Calculate gradients

# Print gradients

Exploring these advanced operations empowers us to harness the full power of PyTorch tensor functionality in complex deep learning models.


No comments yet. Why don’t you start the discussion?

Leave a Reply

Your email address will not be published. Required fields are marked *