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:
- antorcha.mm().
- antorcha.matmul().
- antorcha.bmm()
- 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.
Python3
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.
Python3
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.
argumento_1 |
argumento_2 |
Acción tomada |
unidimensional | unidimensional | El producto escalar se calcula |
bidimensional | bidimensional | Se realiza la multiplicación general de arrays. |
unidimensional | bidimensional | El tensor-1 se pretende con un ‘1’ para que coincida con la dimensión del tensor-2 |
bidimensional | unidimensional | Se calcula el producto array-vector |
1/N-dimensional (N>2) | 1/N-dimensional (N>2) | Se realiza la multiplicación de arrays por lotes. |
Ejemplo 1: Argumentos de la misma dimensión
Python3
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
Python3
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)
Python3
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.
Python3
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:
Python3
# 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])
Publicación traducida automáticamente
Artículo escrito por erakshaya485 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA