Pandas & NumPy Academy · Aula

Multiplicação de matrizes com np.matmul e @

Multiplique matrizes corretamente com np.matmul e o operador @, distinguindo * elemento a elemento da verdadeira multiplicação de matrizes.

Aula 1 de 413 etapas

Multiplicação de matrizes com np.matmul e @ é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Pandas & NumPy Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Pandas & NumPy Academy inclui 4 aulas no total.

Por que a multiplicação de matrizes é importante

A multiplicação de matrizes está no centro da ciência de dados e do aprendizado de máquina. Ela fundamenta redes neurais, redução de dimensionalidade e transformações lineares. Em Python, o NumPy oferece duas maneiras simples de multiplicar matrizes: a função np.matmul() e o operador @, introduzido no Python 3.5. Ambas são rápidas, vetorizadas e muito mais eficientes do que loops Python aninhados.

As regras da multiplicação de matrizes

Para duas matrizes A e B, o produto A @ B só é válido quando o número de colunas em A é igual ao número de linhas em B. Se A tiver forma (m, n) e B tiver forma (n, k), o resultado terá forma (m, k). Essa regra é chamada de restrição das dimensões internas e se aplica independentemente da função do NumPy utilizada.

import numpy as np
A = np.array([[1, 2], [3, 4]])   # shape (2, 2)
B = np.array([[5, 6], [7, 8]])   # shape (2, 2)
C = A @ B
print(C)  # [[19 22] [43 50]]

np.matmul versus o operador @

np.matmul(A, B) e A @ B produzem resultados idênticos para matrizes bidimensionais. O operador @ é simplesmente açúcar sintático — internamente, ele chama __matmul__, que o NumPy implementa usando a mesma rotina BLAS em nível C. Use @ no código cotidiano por sua legibilidade; use np.matmul quando quiser passar a função como objeto chamável ou tratar explicitamente casos especiais.

import numpy as np
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print(np.matmul(A, B))   # same as A @ B
print(A @ B)             # same result

Distinguindo @ de * e np.dot

O NumPy tem três funções de multiplicação que são fáceis de confundir. A * B é uma multiplicação elemento a elemento (produto de Hadamard). np.dot(A, B) se comporta como np.matmul para matrizes bidimensionais, mas tem semântica diferente para dimensões maiores. A @ B é estritamente uma multiplicação de matrizes e segue precisamente a definição matemática — prefira-o a np.dot em operações com matrizes.

import numpy as np
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print('element-wise:', A * B)    # [[5 12] [21 32]]
print('matmul:', A @ B)          # [[19 22] [43 50]]

A multiplicação de matrizes não é comutativa

Diferentemente da multiplicação escalar, a multiplicação de matrizes não é comutativa: em geral, A @ B é diferente de B @ A. Talvez as formas nem sejam compatíveis nas duas direções. Isso é importante ao escrever transformações — a ordem das operações altera o resultado. Sempre controle qual matriz está à esquerda e qual está à direita.

import numpy as np
A = np.array([[1, 2], [3, 4]])
B = np.array([[0, 1], [1, 0]])
print('A @ B:', A @ B)   # [[2 1] [4 3]]
print('B @ A:', B @ A)   # [[3 4] [1 2]]  -- different!

Multiplicação de matrizes em lotes

Quando suas matrizes têm mais de duas dimensões, np.matmul e @ tratam as dimensões iniciais adicionais como dimensões de lote e multiplicam as matrizes em paralelo. Por exemplo, uma matriz de forma (32, 3, 4) multiplicada por uma de forma (32, 4, 5) produz um resultado de forma (32, 3, 5) — 32 multiplicações independentes de 3×4 @ 4×5 de uma só vez. É assim que as estruturas de aprendizado profundo processam lotes pequenos com eficiência.

import numpy as np
batch_A = np.random.rand(32, 3, 4)
batch_B = np.random.rand(32, 4, 5)
result = batch_A @ batch_B
print(result.shape)  # (32, 3, 5)

Multiplicação de matriz por vetor

Um caso especial comum é multiplicar uma matriz por um vetor. Se A tiver forma (m, n) e v for uma matriz unidimensional de comprimento n, então A @ v produzirá uma matriz unidimensional de comprimento m. O NumPy cuida automaticamente do alinhamento das formas — você não precisa remodelar v como um vetor coluna. Esse padrão aparece em toda parte: na aplicação de pesos em regressão linear, na projeção de características e no cálculo simultâneo de produtos escalares para cada linha.

import numpy as np
A = np.array([[1, 2, 3], [4, 5, 6]])  # (2, 3)
v = np.array([1, 0, -1])              # (3,)
print(A @ v)   # [1-3, 4-6] = [-2, -2]

Desempenho: @ versus loops Python

A multiplicação de matrizes do NumPy chama rotinas BLAS/LAPACK otimizadas e é executada em código C compilado. Um loop aninhado em Python puro que implemente a mesma operação costuma ser 100 a 1.000 vezes mais lento para matrizes grandes. Quando precisar repetir produtos de matrizes em um pipeline de dados — transformações de características, projeções de PCA, atualizações de pesos — use sempre @ ou np.matmul e nunca implemente o loop interno por conta própria.

import numpy as np, time
A = np.random.rand(500, 500)
B = np.random.rand(500, 500)
t0 = time.time()
C = A @ B
print(f'NumPy: {(time.time()-t0)*1000:.1f} ms')  # single-digit ms

Encadeando vários produtos de matrizes

Você pode encadear várias operações @ em uma expressão: A @ B @ C é avaliada da esquerda para a direita. O NumPy não otimiza automaticamente a ordem das multiplicações (ao contrário do MATLAB com mtimes); portanto, se as matrizes tiverem tamanhos muito diferentes, a ordem poderá afetar a velocidade. Para três ou mais matrizes, considere usar np.linalg.multi_dot([A, B, C]), que seleciona automaticamente o agrupamento mais eficiente.

import numpy as np
A = np.random.rand(100, 20)
B = np.random.rand(20, 50)
C = np.random.rand(50, 10)
result = np.linalg.multi_dot([A, B, C])
print(result.shape)  # (100, 10)

Erros comuns de forma e como corrigi-los

O erro mais comum na multiplicação de matrizes é uma incompatibilidade de dimensões: ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0. Para corrigi-lo, verifique as dimensões com A.shape e certifique-se de que as dimensões internas coincidem. Se tiver um vetor linha de dimensão (n,) que precise ser tratado como um vetor coluna (n, 1), use v.reshape(-1, 1). Se precisar da transposta, use A.T.

import numpy as np
A = np.ones((3, 4))
B = np.ones((3, 4))  # wrong -- inner dims 4 != 3
try:
    A @ B
except ValueError as e:
    print('Error:', e)
print('Fix:', (A @ B.T).shape)  # (3, 3)

Exemplo prático: transformação de características

Um caso de uso típico em ciência de dados: tem um conjunto de dados X com dimensão (n_samples, n_features) e uma matriz de pesos W com dimensão (n_features, n_outputs). O produto de matrizes X @ W aplica uma transformação linear a cada amostra simultaneamente, produzindo a dimensão (n_samples, n_outputs). Esse é o cálculo central de uma camada linear em uma rede neural e da previsão por regressão linear.

import numpy as np
n_samples, n_features, n_outputs = 200, 10, 3
X = np.random.rand(n_samples, n_features)
W = np.random.rand(n_features, n_outputs)
b = np.zeros(n_outputs)
predictions = X @ W + b   # shape (200, 3)
print(predictions.shape)

Verificação rápida

Teste sua compreensão da multiplicação de matrizes do NumPy.

Recapitulação da lição

Nesta lição, você aprendeu que: np.matmul e @ implementam a multiplicação matricial verdadeira (não elemento a elemento), as dimensões internas das duas matrizes precisam coincidir e @ permite a multiplicação em lotes nas dimensões iniciais. A seguir, exploraremos determinantes, inversas e transpostas — as operações que indicam se uma matriz pode ser "desfeita".

Grátis para começar

Aprenda Python com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
30
Aulas
120

Perguntas Frequentes

A aula “Multiplicação de matrizes com np.matmul e @” é grátis?

Sim — o texto completo de “Multiplicação de matrizes com np.matmul e @” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Pandas & NumPy Academy, atualize para CoddyKit PRO. O curso de Pandas & NumPy Academy inclui 4 aulas no total.

O que vou aprender em “Multiplicação de matrizes com np.matmul e @”?

Multiplique matrizes corretamente com np.matmul e o operador @, distinguindo * elemento a elemento da verdadeira multiplicação de matrizes. Você pratica Pandas & NumPy Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Pandas & NumPy Academy?

Nenhuma experiência prévia é necessária. Pandas & NumPy Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Multiplicação de matrizes com np.matmul e @”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Pandas & NumPy Academy?

Sim. Cada aula de Pandas & NumPy Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Multiplicação de matrizes com np.matmul e @
  2. Determinantes, inversas e transpostas
  3. Resolução de sistemas lineares
  4. Visão geral de autovalores e SVD
← Voltar para Pandas & NumPy Academy