Python – Multiplicación de arrays usando Pytorch

La multiplicación de arrays es una parte integral de la computación científica. Se vuelve complicado cuando el tamaño de la array es enorme. Una de las formas de calcular fácilmente el producto de dos arrays es utilizar los métodos proporcionados por PyTorch. Este artículo cubre cómo realizar la multiplicación de arrays usando PyTorch.

PyTorch y tensores:

Es un paquete que se puede utilizar para proyectos de aprendizaje profundo basados ​​en redes neuronales. Es una biblioteca de código abierto desarrollada por el equipo de investigación de IA de Facebook. Puede reemplazar a NumPy con su poder de GPU. Una de las clases importantes proporcionadas por esta biblioteca es Tensor . No es más que las arrays n-dimensionales proporcionadas por el paquete NumPy. Hay tantos métodos en PyTorch que se pueden aplicar a Tensor, lo que hace que los cálculos sean más rápidos y fáciles. El tensor solo puede contener elementos del mismo tipo de datos.

Multiplicación de arrays con PyTorch:

Los métodos en PyTorch esperan que las entradas sean un Tensor y los que están disponibles con PyTorch y Tensor para la multiplicación de arrays son:

1. antorcha.mm().
2. antorcha.matmul().
3. antorcha.bmm()
4. operador @.

antorcha.mm():

Este método calcula la multiplicación de arrays tomando un Tensor m×n y un Tensor n×p . Puede tratar solo con arrays bidimensionales y no con arrays unidimensionales. Esta función no es compatible con la transmisión. La transmisión no es más que la forma en que se tratan los Tensores cuando sus formas son diferentes. El Tensor más pequeño se transmite para adaptarse a la forma del Tensor más ancho o más grande para las operaciones. La sintaxis de la función se da a continuación. 

antorcha.mm(Tensor_1, Tensor_2, salida=Ninguno)

Los parámetros son dos tensores y el tercero es un argumento opcional. Allí se puede dar otro tensor para contener los valores de salida.

Ejemplo-1: Arrays de la misma dimensión

Aquí ambas entradas son de las mismas dimensiones. Así, la salida también será de la misma dimensión.

import torch as t
  
mat_1 = torch.tensor([[1, 2, 3],
                      [4, 3, 8],
                      [1, 7, 2]])
  
mat_2 = torch.tensor([[2, 4, 1],
                      [1, 3, 6],
                      [2, 6, 5]])
  
torch.mm(mat_1, mat_2, out=None)

Producción:

tensor([[10, 28, 28],
        [27, 73, 62],
        [13, 37, 53]])

Ejemplo 2: Arrays de diferente dimensión

Aquí tensor_1 tiene una dimensión de 2×2, tensor_2 tiene una dimensión de 2×3. Entonces la salida será de 2×3.

import torch as t
  
mat_1 = torch.tensor([[1, 2],
                      [4, 3]])
  
mat_2 = torch.tensor([[2, 4, 1],
                      [1, 3, 6]])
  
torch.mm(mat_1, mat_2, out=None)

Producción:

tensor([[1.4013e-45, 0.0000e+00, 2.8026e-45],
        [0.0000e+00, 5.6052e-45, 0.0000e+00]])

antorcha.matmul():

Este método permite el cálculo de la multiplicación de dos arrays vectoriales (arrays unidimensionales), arrays 2D y también mixtas. Este método también es compatible con las operaciones por lotes y de difusión. En función de las dimensiones de las arrays de entrada se decide la operación a realizar. La sintaxis general se da a continuación.

antorcha.matmul(Tensor_1, Tensor_2, fuera=Ninguno)

La siguiente tabla enumera las diversas dimensiones posibles de los argumentos y las operaciones basadas en ellos.

Ejemplo 1: Argumentos de la misma dimensión

import torch as t
  
# both arguments 1D
vec_1 = torch.tensor([3, 6, 2])
vec_2 = torch.tensor([4, 1, 9])
  
print("Single dimensional tensors :", torch.matmul(vec_1, vec_2))
  
# both arguments 2D
mat_1 = torch.tensor([[1, 2, 3],
                      [4, 3, 8],
                      [1, 7, 2]])
  
mat_2 = torch.tensor([[2, 4, 1],
                      [1, 3, 6],
                      [2, 6, 5]])
  
out = torch.matmul(mat_1, mat_2)
  
print("\n3x3 dimensional tensors :\n", out)

Producción:

Single dimensional tensors : tensor(36)

3x3 dimensional tensors :
 tensor([[10, 28, 28],
        [27, 73, 62],
        [13, 37, 53]])

Ejemplo 2: Argumentos de diferentes dimensiones

import torch
  
# first argument 1D and second argument 2D
mat1_1 = torch.tensor([3, 6, 2])
  
mat1_2 = torch.tensor([[1, 2, 3],
                       [4, 3, 8],
                       [1, 7, 2]])
  
out_1 = torch.matmul(mat1_1, mat1_2)
print("\n1D-2D multiplication :\n", out_1)
  
# first argument 2D and second argument 1D
mat2_1 = torch.tensor([[2, 4, 1],
                       [1, 3, 6],
                       [2, 6, 5]])
  
mat2_2 = torch.tensor([4, 1, 9])
  
# assigning to output tensor
out_2 = torch.matmul(mat2_1, mat2_2)
  
print("\n2D-1D multiplication :\n", out_2)

Producción:

1D-2D multiplication :
 tensor([29, 38, 61])

2D-1D multiplication :
 tensor([21, 61, 59])

Ejemplo 3: argumento N-dimensional (N>2)

import torch
  
# creating Tensors using randn()
mat_1 = torch.randn(2, 3, 3)
mat_2 = torch.randn(3)
  
# printing the matrices
print("matrix A :\n", mat_1)
print("\nmatrix B :\n", mat_2)
  
# output
print("\nOutput :\n", torch.matmul(mat_1, mat_2))

Producción:

matrix A :
 tensor([[[ 0.5433,  0.0546, -0.5301],
         [ 0.9275, -0.0420, -1.3966],
         [-1.1851, -0.2918, -0.7161]],

        [[-0.8659,  1.8350,  1.6068],
         [-1.1046,  1.0045, -0.1193],
         [ 0.9070,  0.7325, -0.4547]]])

matrix B :
 tensor([ 1.8785, -0.4231,  0.1606])

Output :
 tensor([[ 0.9124,  1.5358, -2.2177],
        [-2.1448, -2.5191,  1.3208]])

antorcha.bmm(): 

Este método proporciona la multiplicación de arrays por lotes para los casos en los que ambas arrays a multiplicar tienen solo 3 dimensiones (x×y×z) y la primera dimensión (x) de ambas arrays debe ser la misma. Esto no es compatible con la transmisión. La sintaxis es como se indica a continuación.

torch.bmm( Tensor_1, Tensor_2, determinista=falso, fuera=Ninguno)

El parámetro «determinista» toma valor booleano. Un ‘ falso ‘ hace un cálculo más rápido que no es determinista. Un ‘ verdadero ‘ hace un cálculo más lento, sin embargo, es determinista.

Ejemplo:

En el siguiente ejemplo, la array_1 tiene una dimensión de 2×3×3. La segunda array es de dimensión 2×3×4.

import torch
  
# 3D matrices
mat_1 = torch.randn(2, 3, 3)
mat_2 = torch.randn(2, 3, 4)
  
print("matrix A :\n",mat_1)
print("\nmatrix B :\n",mat_2)
  
print("\nOutput :\n",torch.bmm(mat_1,mat_2))

Producción:

matrix A :
 tensor([[[-0.0135, -0.9197, -0.3395],
         [-1.0369, -1.3242,  1.4799],
         [-0.0182, -1.2917,  0.6575]],

        [[-0.3585, -0.0478,  0.4674],
         [-0.6688, -0.9217, -1.2612],
         [ 1.6323, -0.0640,  0.4357]]])

matrix B :
 tensor([[[ 0.2431, -0.1044, -0.1437, -1.4982],
         [-1.4318, -0.2510,  1.6247,  0.5623],
         [ 1.5265, -0.8568, -2.1125, -0.9463]],

        [[ 0.0182,  0.5207,  1.2890, -1.3232],
         [-0.2275, -0.8006, -0.6909, -1.0108],
         [ 1.3881, -0.0327, -1.4890, -0.5550]]])

Output :
 tensor([[[ 0.7954,  0.5231, -0.7752, -0.1756],
         [ 3.9031, -0.8274, -5.1288, -0.5915],
         [ 2.8488, -0.2372, -3.4850, -1.3212]],

        [[ 0.6532, -0.1637, -1.1251,  0.2633],
         [-1.5532,  0.4309,  1.6527,  2.5167],
         [ 0.6492,  0.8870,  1.4994, -2.3371]]])

** Nota: las arrays varían para cada corrida ya que los valores aleatorios se llenan dinámicamente.

@ operador:

El operador @ – Simon H, cuando se aplica a arrays, realiza la multiplicación por elementos en arrays 1D y la multiplicación normal de arrays en arrays 2D. Si ambas arrays tienen la misma dimensión, entonces la multiplicación de arrays se lleva a cabo normalmente sin ninguna difusión/anteposición. Si alguna de las arrays tiene una dimensión diferente, primero se realiza la transmisión adecuada y luego se realiza la multiplicación. Este operador también se aplica a las arrays N-dimensionales.

Ejemplo:

# single dimensional matrices
oneD_1 = torch.tensor([3, 6, 2])
oneD_2 = torch.tensor([4, 1, 9])
  
  
# two dimensional matrices
twoD_1 = torch.tensor([[1, 2, 3],
                       [4, 3, 8],
                       [1, 7, 2]])
twoD_2 = torch.tensor([[2, 4, 1],
                       [1, 3, 6],
                       [2, 6, 5]])
  
# N-dimensional matrices (N>2)
  
# 2x3x3 dimensional matrix
ND_1 = torch.tensor([[[-0.0135, -0.9197, -0.3395],
                      [-1.0369, -1.3242,  1.4799],
                      [-0.0182, -1.2917,  0.6575]],
  
                     [[-0.3585, -0.0478,  0.4674],
                      [-0.6688, -0.9217, -1.2612],
                      [1.6323, -0.0640,  0.4357]]])
  
# 2x3x4 dimensional matrix
ND_2 = torch.tensor([[[0.2431, -0.1044, -0.1437, -1.4982],
                      [-1.4318, -0.2510,  1.6247,  0.5623],
                      [1.5265, -0.8568, -2.1125, -0.9463]],
  
                     [[0.0182,  0.5207,  1.2890, -1.3232],
                      [-0.2275, -0.8006, -0.6909, -1.0108],
                      [1.3881, -0.0327, -1.4890, -0.5550]]])
  
print("1D matrices output :\n", oneD_1 @ oneD_2)
print("\n2D matrices output :\n", twoD_1 @ twoD_2)
print("\nN-D matrices output :\n", ND_1 @ ND_2)
print("\n Mixed matrices output :\n", oneD_1 @ twoD_1 @ twoD_2)

Producción:

1D matrices output :
 tensor(36)

2D matrices output :
 tensor([[10, 28, 28],
        [27, 73, 62],
        [13, 37, 53]])

N-D matrices output :
 tensor([[[ 0.7953,  0.5231, -0.7751, -0.1757],
         [ 3.9030, -0.8274, -5.1287, -0.5915],
         [ 2.8487, -0.2372, -3.4850, -1.3212]],

        [[ 0.6531, -0.1637, -1.1250,  0.2633],
         [-1.5532,  0.4309,  1.6526,  2.5166],
         [ 0.6491,  0.8869,  1.4995, -2.3370]]])

 Mixed matrices output:
 tensor([218, 596, 562])