Home Machine Learning PyTorch – Reciprocal()

# PyTorch – Reciprocal()

PyTorch – Reciprocal() returns a new tensor that contains the input elements’ reciprocal. Unlike torch, the reciprocal in NumPy. Integral inputs are supported by reciprocal. Reciprocal automatically promotes integral inputs to the default scalar type.

## PyTorch – Reciprocal() Syntax

`torch.tensor(data)`

According to the syntax above, the data is an array with several dimensions.

Torch.reciprocal()

The PyTorch function reciprocal() returns the reciprocal of each element in the tensor. It needs just a single parameter. The syntax is:

`torch.reciprocal(tensor_object)`

The parameter, tensor_object, is a tensor

### Parameters

The parameters include:

input (Tensor) – the input tensor.

### Keyword Arguments

out (Tensor, optional) – the output tensor.

Example

```rand_val = torch.randn(4)
print(rand_val)
torch.reciprocal(rand_val)```

### Example: One dimension tensor

In this example, we’ll make a tensor with one dimension and five elements, then return the tensor’s reciprocal of those five elements.

```#first import the torch module

import torch

#create a 1D tensor
tensor_data = torch.tensor([4.34,8.67,11.90,7.56,10.43])

#display
print("The actual elements in the Tensor: ")

print(tensor_data)

print("The resultant reciprocals for the tensor are as follows")

print(torch.reciprocal(tensor_data))```

### Example: Generating a 2-dimensional tensor

To demonstrate how to generate a tensor with two dimensions and five elements per row, we’ll create a tensor and then return the inverse of the elements.

```#first import the torch module

import torch

#create a 2D tensor
tensor_data = torch.tensor([[1.34,5.67,8.90,4.56,7.43],[1,2,3,4,5]])

#display
print("The actual elements in the Tensor are: ")
print(tensor_data)

print("The reciprocals are as follows:")
print(torch.reciprocal(tensor_data))```

### Utilizing a CPU

We must create a tensor with a cpu() function to execute a reciprocal() process on the CPU. It will operate on a computer with a CPU. This time, we can use the cpu() function when building a tensor.

The syntax is:

`torch.tensor(tensor_data).cpu()`

### Example: One dimensional tensor with five elements

In this example, we’ll generate a tensor with one dimension and five elements on the CPU, then return the tensor’s reciprocal.

```#first import the torch module
import torch

#create a 1D tensor
tensor_data = torch.tensor([4.34,8.67,11.90,7.56,10.43]).cpu()

#display
print("The actual elements in the Tensor are: ")
print(tensor_data)

print("The resulting reciprocals include")
print(torch.reciprocal(tensor_data))```

### Example: 2 Dimensional tensors with five components

In this example, we’ll generate a two-dimensional tensor with five components in each row on the computer and then return the inverse of the elements.

```#first import the torch module

import torch

#create a 2D tensor
tensor_data = torch.tensor([[4.34,8.67,11.90,7.56,10.43],[1,2,3,4,5]]).cpu()

#display
print("The actual elements in the Tensor comprise of ")
print(tensor_data)

print("The resulting reciprocals include the following")
print(torch.reciprocal(tensor_data))```

### Example: Establishing Normalization of Log

```def normal_normalization_of_logs(x, mean, lg_var, avg=False, reduce=True, dim=None):
new_log_norm = -(x - mean) * (x - mean)
new_log_norm *= torch.reciprocal(2.*lg_var.exp())
new_log_norm += -0.5 * lg_var
new_log_norm += -0.5 * torch.log(2. * PI)

if reduce:
if avg:
else:
else:
return new_log_norm```

### Example: Handling Laplacian Coordinates

```def handle_laplacian_coordinates(self, pred, block_id):

r''' provides the laplacian coordinates for the specified block and the forecasts.

The surrounding vertices and the number of neighbors important to the weight
matrix are found using the helper matrices.

If a vertex has fewer neighbors than the maximum of 8, the index -1 is utilized,
which points to the extra zero vertexes.

Arguments:
pred (tensor): responsible for handling vertex predictions
block_id (int): deformation block id (1,2 or 3)
'''
size_of_batch = pred.shape
number_of_vertices = pred.shape

# Add "zero vertexes" for vertices with less than eight neighbors
var_vertex = torch.cat(
[pred, torch.zeros(size_of_batch, 1, 3).to(self.device)], 1)
assert(var_vertex.shape == (size_of_batch, number_of_vertices +1, 3))

# Get eight neighbors for each vertex; if a vertex has less, the
# remaining indices are -1
var_indices = torch.from_numpy(
self.lape_idx[block_id-1][:, :8]).to(self.device)
assert(var_indices.shape == (num_vert, 8))
var_weights = torch.from_numpy(
self.lape_idx[block_id-1][:, -1]).float().to(self.device)
var_weights = torch.reciprocal(weights)
var_weights = var_weights.view(-1, 1).expand(-1, 3)
vertex_select = var_vertex[:, var_indices.long(), :]
assert(vertex_select.shape == (size_of_batch, number_of_vertices, 8, 3))
var_laplace = vertex_select.sum(dim=2)  # Add neighbours
var_laplace = torch.mul(var_laplace, var_weights)  # Multiply by weights
var_laplace = torch.sub(pred, var_laplace)  # Subtract from prediction
assert(var_laplace.shape == (size_of_batch, number_of_vertices, 3))
return var_laplace```

### torch.rsqrt() Method in Python PyTorch

Each member of the input tensor’s square-root reciprocal is calculated using the torch.rsqrt() method. It accepts inputs with real and complex values. The matching element in the output tensor is NaN if an element in the input tensor is zero.

The syntax is as follows:

`torch.rsqrt(input)`

#### Parameters

The torch.rsqrt() takes a single parameter, i.e., input which refers to the input tensor

#### Output

The resultant output is a tensor with a reciprocal of square root.

### Steps

Add the necessary library. The essential Python library for each of the ensuing examples is the torch. Please make certain that it is already installed.

`import torch`

Subsequently, start by creating a torch tensor and printing it as follows:

```var_input = torch.randn(3,4)
print("Tensor Input is:\n", var_input)```

Use the torch to calculate the reciprocal of the square root of each input tensor torch. rsqrt(input). The input tensor is called input here.

`var_reciprocal = torch.rsqrt(input)`

Prepare the reciprocal values for the computed tensor to be displayed.

`print("SQRT of the Reciprocal Tensor:\n", var_reciprocal)`

#### Example: Using real and complex values to calculate the reciprocal of the square root

This Python application calculates the reciprocal of the square root of input tensors with real and complex values.

```# Import the required library
import torch

# define an input tensor
var_input = torch.tensor([1.2, 3., 4., 4.2, -3.2])

# print the above-defined tensor
print("The Tensor input is:\n", var_input)

# compute the reciprocal of the square root
var_reciprocal = torch.rsqrt(var_input)

# print the above-computed tensor
print("Reciprocal SQRT Tensor:\n", var_reciprocal)
print("............................")

# define a complex input tensor
var_input = torch.tensor([1.2+2j, 3.+4.j, 4.2-3.2j])

# print the above-defined tensor
print("Tensor Input Variable:\n", var_input)

# compute the reciprocal of the square root
var_reciprocal = torch.rsqrt(var_input)

# print the above-computed tensor
print("The Reciprocal SQRT Tensor:\n", var_reciprocal)```

Note that the Reciprocal SQRT tensor member that corresponds to a zero in the input tensor is NaN.

#### Example: Computing the reciprocal of the square root

```# Import the required library
import torch

# define an input tensor
var_input = torch.randn(3,4)

# print the above-defined tensor
print("The Tensor's Input is:\n", var_input)

# compute the reciprocal of the square root
var_reciprocal = torch.rsqrt(var_input)

# print the above-computed tensor
print("The Reciprocal SQRT Tensor:\n", var_reciprocal)
print("......................................")

# define a complex input tensor
var_real = torch.randn(3,3)
var_imag = torch.randn(3,3)
var_input = torch.complex(var_real, var_imag)

# print the above-defined tensor
print("The Tensor's Input is:\n", var_input)

# compute the reciprocal of the square root
var_reciprocal = torch.rsqrt(var_input)

# print the above-computed tensor
print("The Reciprocal SQRT Tensor:\n", var_reciprocal)```

#### Example: Using torch.rsqrt() to compute reciprocal of 1-dimensional float tensor

In this example, the reciprocal of the square root of a one-dimensional float tensor is computed using the torch.rsqrt() method. Additionally, there are negative and zero values in the tensor. The input tensor, in this case, has a third element that is zero and an rsqrt of inf, and a fourth element that is a negative number and an rsqrt of nan.

```# Python program to compute the reciprocal of
# square root of a tensor
# importing torch
import torch

# define the input tensor
var_a = torch.tensor([1.2, 0.32, 0., -32.3, 4.])

# print the input tensor
print("The tensor  is:\n", var_a)

# compute the reciprocal square root
var_result = torch.rsqrt(a)

# printing the results computed
print("rsqrt of the tensor is:\n", var_a result)```

#### Example: rsqrst of a complex 1-dimensional tensor

In the example ensuing, the torch calculates the rsqrt of a one-dimensional complex tensor.rsqrt() function. You might notice that you obtain a different number with each run because the complex numbers are generated using a random number generator.

```# Python program to compute the reciprocal of
# square root of a complex tensor
# importing torch
import torch

# define the input tensor
var_a a = torch.randn(4, dtype=torch.cfloat)

# print the input tensor
print("The original tensor is:\n", var_a a)

# compute reciprocal square root
var_a result = torch.rsqrt(var_a a)

# print the computed result
print("rsqrt of the tensor is:\n", var_a result)```

#### Example: 3-D tensor’s rsqrt

In the example below, we use torch.rsqrt() function to calculate a 3-D tensor’s rsqrt. You might note that you obtain a different number with each run because we will also engage the services of a random number generator in generating the numbers in this case. The rsqrt of a multidimensional tensor element is computed similarly to one-dimensional tensors.

```# Python program to compute the reciprocal of
# square root of a multi-dimensional tensor
# importing torch
import torch

# define the input tensor
var_a a = torch.randn(5, 6, 5)

# print the input tensor
print("tensor a:\n", var_a a)

# compute reciprocal square root
var_a result = torch.rsqrt(var_a a)

# print the computed result
print("The rsqrt of the given tensor is :\n", var_a result)```

### Conclusion

In this PyTorch article, we have used the reciprocal() method to return the reciprocal of each element in the tensor.