¿Cómo realizar una división por elementos en tensores en PyTorch?

En este artículo, entenderemos cómo realizar la división por elementos de dos tensores en PyTorch. Para realizar la división de tensores por elementos, podemos aplicar el método torch.div() . Toma dos tensores (dividendo y divisor) como entradas y devuelve un nuevo tensor con el resultado de la división por elementos. Podemos usar la siguiente sintaxis para calcular la división por elementos:

Sintaxis: torch.div(entrada, otro, modo_redondeo=Ninguno)

Parámetros:

• entrada: el primer tensor de entrada (dividendo).
• otro: el segundo tensor de entrada (divisor).
• rounding_mode: El tipo de redondeo aplicado al resultado.

Retorno: devuelve un nuevo tensor con división por elementos del tensor de entrada por el otro tensor .

Ejemplo:

Inputs:
tensor([10., 25., 30.])
tensor([2., -5., 10.])

Output:
tensor([5., -5., 3.])

Inputs:
tensor([3., 0., 23.])
tensor([2., -5., 0.])

Output:
tensor([1.5, -0., inf])

Comprendamos cómo funciona la división de tensores por elementos con la ayuda de algunos ejemplos de Python.

Ejemplo 1:

En el siguiente ejemplo, realizamos la división por elementos de dos tensores 1-D usando el método de PyTorch torch.div() .

# Python program to divide two 1D tensors
# element-wise using torch.div() method
# importing torch
import torch
 
# creating first tensor
A = torch.tensor([0.0312,  0.3401,  0.1645, -1.0781])
print("Tensor A:\n", A)
 
# creating second tensor
B = torch.tensor([-1.8584,  0.5706, -0.8994,  2.2492])
print("\nTensor B:\n", B)
 
# divide A by B
result = torch.div(A, B)
print("\nElement-wise Division Output:\n", result)

Producción:

Tensor A:
 tensor([ 0.0312,  0.3401,  0.1645, -1.0781])

Tensor B:
 tensor([-1.8584,  0.5706, -0.8994,  2.2492])

Element-wise Division Output:
 tensor([-0.0168,  0.5960, -0.1829, -0.4793])

Ejemplo 2:

En el siguiente ejemplo, realizamos la división por elementos de un tensor 2D por un tensor 2D usando el método de PyTorch torch.div() . También aplicamos diferentes modos de redondeo.

# Python program to divide two
# 2D tensors element-wise
# importing torch
import torch
 
# defining first 2D tensor
a = torch. tensor([[-1.8665,  0.6341,  0.8920],
                   [-0.1712,  0.3949,  1.9414],
                   [-1.2088, -1.0375, -1.3087],
                   [0.9161, -0.2972,  1.5289]])
print("Tensor a:\n", a)
 
# defining second 2D tensor
# b = torch.randn(4,3)
b = torch. tensor([[-0.2187,  0.5252, -0.5840],
                   [1.5293, -0.4514,  1.8490],
                   [-0.7269, -0.1561, -0.0629],
                   [-0.5379, -0.9751,  0.6541]])
print("\nTensor b:\n", b)
 
# computing element-wise division
print("\nElement-wise Division:")
result1 = torch.div(a, b)
print("\nResult:\n", result1)
result2 = torch.div(a, b, rounding_mode='trunc')
print("\nResult with rounding_mode='trunc':\n", result2)
result3 = torch.div(a, b, rounding_mode='floor')
print("\nResult with rounding_mode='floor':\n", result3)

Producción:

Tensor a:
 tensor([[-1.8665,  0.6341,  0.8920],
        [-0.1712,  0.3949,  1.9414],
        [-1.2088, -1.0375, -1.3087],
        [ 0.9161, -0.2972,  1.5289]])

Tensor b:
 tensor([[-0.2187,  0.5252, -0.5840],
        [ 1.5293, -0.4514,  1.8490],
        [-0.7269, -0.1561, -0.0629],
        [-0.5379, -0.9751,  0.6541]])

Element-wise Division:

Result:
 tensor([[ 8.5345,  1.2073, -1.5274],
        [-0.1119, -0.8748,  1.0500],
        [ 1.6630,  6.6464, 20.8060],
        [-1.7031,  0.3048,  2.3374]])

Result with rounding_mode='trunc':
 tensor([[ 8.,  1., -1.],
        [-0., -0.,  1.],
        [ 1.,  6., 20.],
        [-1.,  0.,  2.]])

Result with rounding_mode='floor':
 tensor([[ 8.,  1., -2.],
        [-1., -1.,  1.],
        [ 1.,  6., 20.],
        [-2.,  0.,  2.]])

Ejemplo 3:

En el siguiente ejemplo, realizamos la división por elementos de un tensor 3-D por un tensor 1-D usando el método de PyTorch torch.div() .

# Python program to divide a 3D tensor by
# a 1D tensor element-wise
# Importing torch
import torch
 
# defining tensors
a = torch.randn(3, 2, 2)
b = torch.randn(2)
 
# printing the matrices
print("Tensor a :\n", a)
print("\nTensor b :\n", b)
 
# divide tensor a by b
result = torch.div(a, b)
print("\nElementwise Division Output :\n", result)

Producción:

Tensor a :
 tensor([[[-0.7549,  1.8301],
         [-0.5545,  1.3180]],

        [[ 0.1159,  0.8394],
         [ 0.0452, -1.2860]],

        [[ 0.3850, -0.9654],
         [-1.5530, -0.8627]]])

Tensor b :
 tensor([-1.2378,  0.2153])

Elementwise Division Output :
 tensor([[[ 0.6098,  8.5011],
         [ 0.4480,  6.1226]],

        [[-0.0937,  3.8991],
         [-0.0365, -5.9739]],

        [[-0.3110, -4.4844],
         [ 1.2546, -4.0074]]])