*721*

Table of Contents

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: return torch.mean(new_log_norm, dim) else: return torch.sum(new_log_norm, dim) 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[0] number_of_vertices = pred.shape[1] # 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.

An open-source framework called PyTorch is offered together with the Python programming language. The data is kept in a multidimensional array called a tensor. We additionally imported the torch module to use the tensor. Further, the function responsible for producing a tensor is called tensor().

The rsqrt() method in PyTorch calculates the square root reciprocal of each input tensor member. Tensors with real and complex values are both acceptable. The square root’s reciprocal of a negative number is returned as “NaN” (not a number), and “inf” is produced for zero. A mathematical formula determines the reciprocal of a number’s square root input.