Converting Between Pytorch Tensors and Numpy Arrays in Python

Conversion Of Pytorch Tensor To Numpy (1)

Tensors are primary data structures that are used widely for various purposes. Pytorch is a popular library in Python that contains these structures for various uses among researchers and data scientists. Similarly, the numerical Python or NumPy library is also a very important library for mathematical computations in Python. The need for converting these array-like tensors from PyTorch to NumPy arrays can vary based on different uses.

The interoperability and integration with existing or legacy code can be easily done since Python facilitates this method of conversion. Converting PyTorch tensors to numpy arrays allows us to align our datasets with existing codes since with numpy it is easier to visualize our data, whereas PyTorch is mainly used for computations. By converting pytorch tensors to numpy arrays, users can visualize intermediate results or outputs for better understanding.

Also read: Convert A Tensor To Numpy Array In Tensorflow-Implementation

Numpy also has a huge range of built-in functions for scientific computations, data processing, linear algebra, and signal processing. To leverage these functions it is often essential to convert pytorch tensors into numpy arrays. In this article, we will learn about what tensors in pytorch are and how we can convert them into numpy arrays in Python.

An Introduction to Pytorch Tensors

Pytorch tensors are similar to NumPy arrays in terms of storing numerical data. They are multi-dimensional and find their use in many fields such as scientific research, linear algebra, and data processing. Pytorch tensors offer some additional features for optimization processes, such as:

  • Multi-dimensionality: Many different data types such as scalars, matrices, and vectors can be represented using these tensors. They can have any number of dimensions making them extremely flexible for various machine learning applications.
  • GPU Acceleration: Pytorch provides seamless integration with NVIDIA and CUDA’s parallel computing platform, which helps it leverage accelerated computations from graphical processing units or GPUs. This helps especially in training deep learning models where the datasets are large and computations are time-consuming.
  • Automatic Differentiation: Pytorch tensors come with an in-built function for automatic differentiation. The autograd module in Pytorch helps it compute gradients automatically in neural networks without computing them manually through backpropagation algorithms.
  • Supports various data types: Pytorch supports various data types such as integers ( int8, int16, and int32) as well as floats(float32 and float64). Users also have the flexibility to customize their data types. This provides programmers with a huge range of datasets to work with, which is essential for machine learning algorithms.

Suggested: Python NumPy: Solving Coupled Differential Equations.

Converting Between Pytorch Tensors and Numpy Arrays

Even though it might sound daunting at first, it is rather easy to convert pytorch tensors to numpy arrays in Python. There are inbuilt functions, the .numpy() function which can be used to convert pytorch tensors to numpy arrays. We will look at it in this section.

Let’s create a dummy Pytorch tensor using the torch.tensor() function by importing torch. Next, using the .numpy() function, we can convert the pytorch tensor in the following way.

#importing required module
import torch

# Creating a PyTorch tensor
tensor = torch.tensor([1, 2, 3])

# Converting tensor to NumPy array
numpy_array = tensor.numpy()

print("the numpy array from the pytorch tensor is:",numpy_array)

The output would be:

the numpy array from the pytorch tensor is: [1 2 3]

Let’s take an instance where we can apply this conversion knowledge practically. In the code given below, we will generate synthetic data for training a simple neural network for linear regression in Pytorch. We will generate the synthetic data using numpy and convert it to Pytorch tensors, then we will define the regression model using Pytorch. The predicted values are then converted back to numpy arrays for visualization using Matplotlib.

#importing required modules
import torch
import numpy as np
import matplotlib.pyplot as plt

# Generating synthetic data
X = np.random.rand(100, 1)
y = 2 * X + 1 + 0.1 * np.random.randn(100, 1) #simple linear regression equation

# Converting NumPy arrays to PyTorch tensors
X_tensor = torch.from_numpy(X).float()
y_tensor = torch.from_numpy(y).float()

# Defining the linear regression model
class LinearRegression(torch.nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.linear = torch.nn.Linear(1, 1)

    def forward(self, x):
        return self.linear(x)

# Instantiating the model
model = LinearRegression()

# Defining loss function and optimizer
criterion = torch.nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# Training the model
for epoch in range(100):
    # Forward pass
    outputs = model(X_tensor)
    loss = criterion(outputs, y_tensor)
    # Backward pass and optimization

# Converting predicted values to NumPy array for plotting
predicted = model(X_tensor).detach().numpy()

# Plotting the data and regression line
plt.scatter(X, y, label='Original data')
plt.plot(X, predicted, color='red', label='Fitted line')
plt.title('Linear Regression')

The output would be:

Linear Regression With Conversion Between Pytorch Tensors And Numpy Arrays
Linear Regression With Conversion Between Pytorch Tensors And Numpy Arrays

Recommended: Creating Custom Datasets in PyTorch


We have gone through what PyTorch tensors are and how they are different from numpy arrays. The interoperability offered by Python among these two data types enables us to integrate existing code with customized data types for ease of use and optimization purposes. There are a lot of advantages of Pytorch tensors in the fields of deep learning, scientific computations, and data processing. We have also seen a practical implementation of this conversion using a built-in function in a neural network for a simple linear regression model. We hope you found this article helpful!