Table of Contents

This PyTorch article will look at converting radians to degrees using the rad2deg() method. PyTorch is an open-source framework that uses Python as its programming language.

A tensor is a multidimensional array used to store data. Consequently, we must first load the torch module to use a tensor. Further, tensor is the method used to build a tensor().

torch.tensor(data)

In this case, the data is a multidimensional array.

## Torch.rad2deg()

Rad2deg() in PyTorch translates tensor radians to degrees. It only requires one parameter. The syntax is as follows:

torch.rad2deg(tensor_object)

### Parameter

tensor_object refers to a tensor

### Return Value

The return value gives you a new array tensor with degrees.

### What is a torch.Tensor?

A torch.Tensor is a multidimensional matrix with only one data type’s elements. Additionally, torch. Tensor is a shorthand for the default tensor type (torch.FloatTensor).

#### Ten types of tensors

Torch defines ten tensor types, each with its CPU and GPU variant:

#### Type 1:data type: 32-bit floating point

- The dtype is torch.float32 or torch.float
- The CPU tensor is torch.FloatTensor
- The GPU tensor is torch.cuda.FloatTensor

#### Type 2: data type: 64-bit floating point

- The dtype is torch.float64 or torch.double
- The CPU tensor is torch.DoubleTensor
- The GPU tensor is torch.cuda.DoubleTensor

#### Type 3: data type: 16-bit floating point 1

- The dtype is torch.float16 or torch.half
- The CPU tensor is the torch.HalfTensor
- The GPU tensor is torch.cuda.HalfTensor

#### Type 4: data type: 16-bit floating point 2

- The dtype is the torch.bfloat16
- The CPU tensor is torch.BFloat16Tensor
- The GPU tensor is torch.cuda.BFloat16Tensor

#### Type 5: data type: 32-bit complex

- The dtype is the torch.complex32

#### Type 6: data type: 64-bit complex

- The dtype is the torch.complex64

#### Type 7: data type: 128-bit complex

- The dtype is torch.complex128 or torch.cdouble

#### Type 8: data type: 8-bit integer (unsigned)

- The dtype is the torch.uint8
- The CPU tensor is torch.ByteTensor
- The GPU tensor is torch.cuda.ByteTensor

#### Type 9: data type: 16-bit integer (signed)

- The dtype is torch.int16 or torch.short
- The CPU tensor is torch.ShortTensor
- The GPU tensor is torch.cuda.ShortTensor

#### Type 10: data type: 32-bit integer (signed)

- The dtype is torch.int32 or torch.int
- The CPU tensor is torch.IntTensor
- The GPU tensor is torch.cuda.IntTensor

#### 11. data type: 64-bit integer (signed)

- The dtype is torch.int64 or torch.long
- The CPU tensor is torch.LongTensor
- The GPU tensor is torch.cuda.LongTensor

#### 12. data type: Boolean

- The dtype is the torch.bool
- The CPU tensor is torch.BoolTensor
- The GPU tensor is torch.cuda.BoolTensor

The torch.Tensor() constructor can be used to create a tensor from a Python list or sequence:

torch.tensor([[1., -1.], [1., -1.]]) tensor([[ 1., -1.], [ 1., -1.]]) torch.tensor(np.array([[4, 5, 6], [10, 8, 9]])) tensor([[4, 5, 6], [7, 8, 9]])

The function torch.tensor() always copies data. To prevent a copy, use requires_grad_() or detach() if you only want to update the requires_grad_flag of a Tensor data. Use torch.as_tensor() if you have a numpy array and wish to avoid a copy.

By giving a torch.dtype alongside or without a torch.device to a tensor creation op or constructor, a tensor of a certain data type can be created:

torch.zeros([2, 4], dtype=torch.int32) tensor([[ 0, 0, 0, 0], [ 0, 0, 0, 0]], dtype=torch.int32) cuda0 = torch.device('cuda:0') torch.ones([5, 7], dtype=torch.float64, device=cuda0) tensor([[ 1.0000, 1.0000, 1.0000, 1.0000], [ 1.0000, 1.0000, 1.0000, 1.0000]], dtype=torch.float64, device='cuda:0')

Python’s indexing and slicing notation can be used to access and modify the contents of a tensor:

var_x = torch.tensor([[1, 2, 3], [4, 5, 6]]) print(x[1][2]) tensor(6) x[0][1] = 8 print(x) tensor([[ 1, 8, 3], [ 4, 5, 6]])

Use torch.Tensor.item() in the retrieval of a Python number from a tensor with a single value:

var_x = torch.tensor([[1]]) var_x tensor([[1]]) var_x.item() var_x = torch.tensor(2.5) var_x tensor(2.5000) var_x.item()

With requires_grad=True, a tensor can be built such that torch.autograd records operations on it for automatic differentiation.

var_x = torch.tensor([[1., -1.], [1., 1.]], requires_grad=True) out = var_x.pow(2).sum() out.backward() var_x.grad tensor([[ 2., -2.], [ 2., 2.]])

Each tensor is paired with a torch. Storage is where data is kept. The tensor class also defines numeric operations on storage and gives a multidimensional, strided view of it.

### Example 1: Creating a one-dimensional tensor

In this example, we’ll make a tensor with one dimension and five elements, then convert it to degrees.

#initially, begin by importing the module, torch import torch #creation of a tensor with one dimension var_data = torch.tensor([1.54,5.87,9.10,4.76,7.63]) # show the initial data before conversion print("Actual radians contained in the Tensor: ") print(var_data) print("Conversion of the tensor into degrees") print(torch.rad2deg(var_data))

The Actual radians contained in the Tensor output are represented as follows:

**Example 2: Two-dimensional tensor**

In this example, we will generate a two-dimensional tensor with five elements in each row and convert it to radians.

# start by importing the torch module import torch #create a 2D tensor var_data = torch.tensor([[1.54,5.87,9.10,4.76,7.63],[1,2,3,4,5]]) # show the actual radians before conversion print("Actual radians contained in the Tensor: ") print(var_data) print("Show the resultant degrees after cnversion") print(torch.rad2deg(var_data))

### How to work with the CPU

To run a rad2deg() function on the CPU, we must first create a tensor with a cpu() function. This will be executed on a CPU computer. This time, when we generate a tensor, we may utilize the cpu() function. The syntax is as follows:

torch.tensor(data).cpu()

### Example 1: Using the CPU to generate tensors

In this example, we will use the CPU to generate a tensor with one dimension and five elements and convert it to degrees.

#start by importing the torch module import torch #creation of tensor with one dimension var_data = torch.tensor([1.54,5.87,9.10,4.76,7.63]).cpu() # showing the initial tensor before conversion print(" These are the real radians present in the Tensor: ") print(var_data) print("Resultant degrees after tensor conversion") print(torch.rad2deg(var_data))

**Example 2: Generating a two-Dimensional tensor**

In this example, we will generate a two-dimensional tensor with five elements on the CPU in each row and convert it to radians.

#start by importing the torch module import torch #creation of a tensor with two dimensions var_data = torch.tensor([[1.54,5.87,9.10,4.76,7.63],[1,2,3,4,5]]).cpu() #shows the actual tensor by its conversion print("The Tensor containing actual radians: ") print(var_data) print("The resultant degrees after conversion") print(torch.rad2deg(var_data))

### How to use Mars for converting angles from degrees to radians

The syntax is as follows:

mars.tensor.rad2deg(x, out=None, where=None, **kwargs)

The Parameters are listed below:

x (array_like) - Radian angle

out (Tensor, None, or tuple of Tensor and None, optional) – The location where the result will be stored. If one is provided, it must have a shape to which the inputs broadcast. If no tensor is provided or None is specified, a newly allocated tensor is returned. A tuple (only permitted as a keyword parameter) must be the same length as the number of outputs.

where (array_like, optional) – True values indicate that the ufunc should be calculated at that position, while False values suggest that the value in the output should be left alone.

**kwargs –

Returns are:

y – represents the corresponding degree angle.

The return type here is a Tensor

rad2deg(x) is 180 * x / pi. import mars.tensor as mt mt.rad2deg(mt.pi/2).execute()

### Example: Angles in radians transformed to degrees as input

var_data = torch.tensor([[4.142, -2.142], [7.283, -5.283], [2.570, -0.570]]) torch.rad2deg(var_data)

### Example: Pass a Floating point number in the rad2deg function

torch.rad2deg(torch.tensor([5])) torch.rad2deg(torch.tensor([5],dtype=float))

For the rad2deg function, the tensor is intended to be a floating point number. Long cannot be cast using the Float type. So, we may declare dtype as a float for the tensor and then do the rad2deg function.

### Example: How to Convert Radians to Degrees Using np.arange() and a Function

Because your angle x is in degrees, you’ll want to convert it to radians using several ways, such as np.deg2rad. So the code is:

var_x = np.arange(0, 360, 0.1) # angles represent as degrees starting at 0 to 360 var_y = np.cos(np.deg2rad(var_x)) # conversion of var_x to degrees before application of cosine

### Example: Integrating Rad2deg with other methods

%matplotlib inline import matplotlib.pyplot as plt plt.style.use('seaborn-whitegrid') import numpy as np var_x = np.arange(0, 360, 0.1) var_y = np.cos(np.deg2rad(var_x)) plt.plot(var_x, var_y, 'o', color='blue') plt.xlabel('Angle (Degrees)') plt.ylabel('Cosine')

### Conclusion

We explored the rad2deg() function in this PyTorch Rad2deg article. The latter is responsible for converting the provided tensor angles in radians to degrees. We also executed the tensor on the CPU by examining the two examples. Additionally, rad2deg() is one of the less well-known PyTorch tensors to investigate some procedures for mathematical calculations.

Most importantly, when working with datasets containing variables relating to angles, the rad2deg function is beneficial.