Operaciones eficientes de multiplicación de matrices de NumPy

Introducción

NumPy es una poderosa biblioteca para el cálculo científico en Python. Una de las características más importantes de NumPy es su capacidad para realizar eficientemente varios tipos de multiplicaciones de matrices.

En este tutorial, exploraremos las diferentes operaciones de multiplicación disponibles en NumPy, incluyendo numpy.multiply, numpy.dot, numpy.matmul, los operadores * y @.

Empezando

Antes de adentrarnos en las diferentes operaciones de multiplicación en NumPy, primero abramos el shell de Python escribiendo el siguiente comando en la terminal.

python3

Luego importemos la biblioteca y creemos algunas matrices de muestra que podemos usar para la demostración.

import numpy as np

## Creando matrices de muestra
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

Hemos creado dos matrices A y B, cada una con dos filas y dos columnas. Ahora, exploremos las diferentes operaciones de multiplicación disponibles en NumPy.

numpy.multiply

La función numpy.multiply realiza una multiplicación elemento a elemento entre dos matrices. Las dos matrices deben tener la misma forma. La matriz resultante tendrá la misma forma que las matrices de entrada.

C = np.multiply(A, B)

print(C)
## Salida:
## array([[ 5, 12],
##       [21, 32]])

En este ejemplo, cada elemento en A se multiplica con el elemento correspondiente en B, lo que da como resultado la multiplicación elemento a elemento de las dos matrices.

numpy.dot

La función numpy.dot realiza la multiplicación de matrices entre dos matrices. La primera matriz debe tener el mismo número de columnas que filas tiene la segunda matriz. La matriz resultante tendrá el mismo número de filas que la primera matriz y el mismo número de columnas que la segunda matriz.

C = np.dot(A, B)

print(C)
## Salida:
## array([[19, 22],
##        [43, 50]])

En este ejemplo, hemos realizado la multiplicación de matrices entre las matrices A y B. La matriz resultante C tiene dos filas y dos columnas, como se esperaba.

numpy.matmul

La función numpy.matmul también realiza la multiplicación de matrices entre dos matrices, pero tiene reglas ligeramente diferentes para manejar matrices multidimensionales. Las dos matrices deben tener la misma forma, excepto para las dos últimas dimensiones, que deben coincidir. Si alguna matriz es 1-D, se la promueve a una matriz agregando un 1 a su forma.

C = np.matmul(A, B)

print(C)
## Salida:
## array([[19, 22],
##        [43, 50]])

En este ejemplo, obtenemos el mismo resultado que con numpy.dot. Esto se debe a que nuestras matrices A y B tienen la misma forma, por lo que numpy.matmul se comporta de la misma manera que numpy.dot.

Y hay otro ejemplo diferente:

## define two 3-D arrays
a = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
b = np.array([[[9, 10], [11, 12]], [[13, 14], [15, 16]]])

c = np.matmul(a, b)
d = np.dot(a, b)

print(c)
## Salida:
## array([[[ 31,  34],
##        [ 71,  78]],
##        [[155, 166],
##        [211, 226]]])

print(d)
## Salida:
## array([[[[ 31,  34],
##         [ 43,  46]],
##        [[ 71,  78],
##         [ 99, 106]]],
##       [[[111, 122],
##         [155, 166]],
##        [[151, 166],
##         [211, 226]]]])

En este ejemplo, numpy.matmul realiza la operación de multiplicación de matrices en lotes.

Dado que tanto a como b son matrices 3-D, la salida de numpy.dot tendrá dimensionalidad (2,2,2,2). Las dos primeras dimensiones corresponden a los dos lotes de matrices 2\times2 en a y b. Las dos dimensiones siguientes corresponden al producto punto de cada par de matrices 2\times2 en los lotes:

## the first 2 × 2 result
dot(a[0], b[0]) =
dot([[1, 2],
 [3, 4]],
 [[9, 10],
 [11, 12]]
= [[1*9 + 2*11, 1*10 + 2*12],
   [3*9 + 4*11, 3*10 + 4*12]]
= [[31, 34],
   [43, 46]]

Operador *

El operador * también realiza una multiplicación elemento a elemento entre dos matrices, pero se comporta ligeramente diferente a numpy.multiply. Si las dos matrices tienen la misma forma, el operador * realizará una multiplicación elemento a elemento, al igual que numpy.multiply. Sin embargo, si una de las matrices es un valor escalar, el operador * realizará una multiplicación escalar en cada elemento de la otra matriz.

C = A * B
D = A * 2

print(C)
## Salida:
#array([[ 5, 12],
##       [21, 32]])

print(D)
## Salida:
## array([[2, 4],
##       [6, 8]])

En el primer ejemplo, obtenemos el mismo resultado que con numpy.multiply. En el segundo ejemplo, realizamos una multiplicación escalar en cada elemento de la matriz A.

Operador @

El operador @ realiza la multiplicación de matrices, al igual que numpy.dot y numpy.matmul. Fue introducido en Python 3.5 como un atajo para numpy.matmul.

C = A @ B

print(C)
## Salida:
## array([[19, 22],
##       [43, 50]])

En este ejemplo, usamos el operador @ para realizar la multiplicación de matrices entre las matrices A y B. La matriz resultante C tiene dos filas y dos columnas, al igual que con numpy.dot y numpy.matmul.

Resumen

En este tutorial, hemos explorado las diferentes operaciones de multiplicación disponibles en NumPy. Cada una de estas operaciones tiene sus propias reglas y casos de uso, por lo que es importante elegir la adecuada para su tarea específica. Al dominar estas operaciones, puede realizar eficientemente multiplicaciones de matrices y matrices en Python utilizando NumPy.