Operações Eficientes de Multiplicação de Arrays NumPy

Introdução

NumPy é uma biblioteca poderosa para computação científica em Python. Uma das características mais importantes do NumPy é sua capacidade de realizar eficientemente vários tipos de multiplicações de arrays.

Neste tutorial, exploraremos as diferentes operações de multiplicação disponíveis no NumPy, incluindo os operadores numpy.multiply, numpy.dot, numpy.matmul, * e @.

Começando

Antes de mergulharmos nas diferentes operações de multiplicação em NumPy, vamos primeiro abrir o shell do Python digitando o seguinte comando no terminal.

python3

Em seguida, importe a biblioteca e crie alguns arrays de exemplo que podemos usar para demonstração.

import numpy as np

## Criando arrays de exemplo
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

Criamos dois arrays A e B, cada um com duas linhas e duas colunas. Agora, vamos explorar as diferentes operações de multiplicação disponíveis no NumPy.

numpy.multiply

A função numpy.multiply realiza a multiplicação elemento a elemento entre dois arrays. Os dois arrays devem ter a mesma forma (shape). O array resultante terá a mesma forma dos arrays de entrada.

C = np.multiply(A, B)

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

Neste exemplo, cada elemento em A é multiplicado pelo elemento correspondente em B, resultando na multiplicação elemento a elemento dos dois arrays.

numpy.dot

A função numpy.dot realiza a multiplicação de matrizes entre dois arrays. O primeiro array deve ter o mesmo número de colunas que o segundo array tem linhas. O array resultante terá o mesmo número de linhas que o primeiro array e o mesmo número de colunas que o segundo array.

C = np.dot(A, B)

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

Neste exemplo, realizamos a multiplicação de matrizes entre os arrays A e B. O array resultante C tem duas linhas e duas colunas, como esperado.

numpy.matmul

A função numpy.matmul também realiza a multiplicação de matrizes entre dois arrays, mas possui regras ligeiramente diferentes para lidar com arrays multidimensionais. Os dois arrays devem ter a mesma forma (shape), exceto pelas duas últimas dimensões, que devem ser compatíveis. Se qualquer um dos arrays for 1-D, ele é promovido a uma matriz adicionando um 1 à sua forma.

C = np.matmul(A, B)

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

Neste exemplo, obtemos o mesmo resultado que com numpy.dot. Isso ocorre porque nossos arrays A e B têm a mesma forma, então numpy.matmul se comporta da mesma maneira que numpy.dot.

E há outro exemplo 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)
## Output:
## array([[[ 31,  34],
##        [ 71,  78]],
##        [[155, 166],
##        [211, 226]]])

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

Neste exemplo, numpy.matmul realiza a operação de multiplicação de matrizes em lote (batch matrix multiplication).

Como a e b são arrays 3-D, a saída de numpy.dot terá dimensionalidade (2,2,2,2). As duas primeiras dimensões correspondem aos dois lotes de matrizes 2\times2 em a e b. As duas dimensões seguintes correspondem ao produto escalar (dot product) de cada par de matrizes 2\times2 nos 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 *

O operador * também realiza a multiplicação elemento a elemento (element-wise) entre dois arrays, mas se comporta de maneira ligeiramente diferente do numpy.multiply. Se os dois arrays tiverem a mesma forma (shape), o operador * realizará a multiplicação elemento a elemento, assim como numpy.multiply. No entanto, se um dos arrays for um valor escalar, o operador * realizará a multiplicação escalar em cada elemento do outro array.

C = A * B
D = A * 2

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

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

No primeiro exemplo, obtemos o mesmo resultado que com numpy.multiply. No segundo exemplo, realizamos a multiplicação escalar em cada elemento do array A.

Operador @

O operador @ realiza a multiplicação de matrizes, assim como numpy.dot e numpy.matmul. Ele foi introduzido no Python 3.5 como uma abreviação para numpy.matmul.

C = A @ B

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

Neste exemplo, usamos o operador @ para realizar a multiplicação de matrizes entre os arrays A e B. O array resultante C tem duas linhas e duas colunas, assim como com numpy.dot e numpy.matmul.

Resumo

Neste tutorial, exploramos as diferentes operações de multiplicação disponíveis no NumPy. Cada uma dessas operações tem suas próprias regras e casos de uso, por isso é importante escolher a correta para sua tarefa específica. Ao dominar essas operações, você pode realizar eficientemente multiplicações de arrays e matrizes em Python usando NumPy.