Pandas & NumPy Academy · Lección

Multiplicación de matrices con np.matmul y @

Multiplique matrices correctamente con np.matmul y el operador @, y distinga * elemento a elemento de la verdadera multiplicación matricial.

Lección 1 de 413 pasos

Multiplicación de matrices con np.matmul y @ es una lección gratuita de Pandas & NumPy Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Pandas & NumPy Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.

Por qué es importante la multiplicación de matrices

La multiplicación de matrices es fundamental en la ciencia de datos y el aprendizaje automático. Es la base de las redes neuronales, la reducción de dimensionalidad y las transformaciones lineales. En Python, NumPy ofrece dos formas sencillas de multiplicar matrices: la función np.matmul() y el operador @, introducido en Python 3.5. Ambas son rápidas, vectorizadas y mucho más eficientes que los bucles de Python anidados.

Las reglas de la multiplicación de matrices

Para dos matrices A y B, el producto A @ B solo es válido cuando el número de columnas de A es igual al número de filas de B. Si A tiene forma (m, n) y B tiene forma (n, k), el resultado tiene forma (m, k). Esta regla se denomina restricción de las dimensiones internas y se aplica independientemente de la función de NumPy que utilice.

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 frente al operador @

np.matmul(A, B) y A @ B producen resultados idénticos para matrices 2D. El operador @ es simplemente azúcar sintáctico: internamente llama a __matmul__, que NumPy implementa mediante la misma rutina BLAS a nivel de C. Use @ en el código cotidiano por legibilidad; use np.matmul cuando quiera pasar la función como objeto invocable o gestionar explícitamente casos especiales.

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

Diferencias entre @, * y np.dot

NumPy tiene tres funciones de multiplicación que se confunden fácilmente. A * B es una multiplicación elemento a elemento (producto de Hadamard). np.dot(A, B) se comporta como np.matmul con matrices 2D, pero tiene una semántica diferente con dimensiones superiores. A @ B es estrictamente una multiplicación matricial y sigue con precisión la definición matemática; prefiera este operador a np.dot para trabajar con matrices.

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]]

La multiplicación de matrices no es conmutativa

A diferencia de la multiplicación de escalares, la multiplicación de matrices no es conmutativa: A @ B normalmente difiere de B @ A. Es posible que las formas ni siquiera sean compatibles en ambas direcciones. Esto es importante al escribir transformaciones: el orden de las operaciones cambia el resultado. Compruebe siempre qué matriz está a la izquierda y cuál a la derecha.

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!

Multiplicación de matrices por lotes

Cuando sus matrices tienen más de dos dimensiones, np.matmul y @ tratan las dimensiones iniciales adicionales como dimensiones de lote y multiplican las matrices en paralelo. Por ejemplo, una matriz de forma (32, 3, 4) multiplicada por otra de forma (32, 4, 5) produce un resultado de forma (32, 3, 5): 32 multiplicaciones independientes de 3×4 @ 4×5 a la vez. Así es como los frameworks de aprendizaje profundo procesan los minibatches de forma eficiente.

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)

Multiplicación de matrices por vectores

Un caso especial habitual consiste en multiplicar una matriz por un vector. Si A tiene forma (m, n) y v es una matriz unidimensional de longitud n, entonces A @ v produce una matriz unidimensional de longitud m. NumPy ajusta las formas automáticamente; no necesita reestructurar v como un vector columna. Este patrón aparece en todas partes: al aplicar pesos en regresión lineal, proyectar características y calcular simultáneamente los productos escalares de cada fila.

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]

Rendimiento: @ frente a los bucles de Python

La multiplicación de matrices de NumPy llama a rutinas BLAS/LAPACK optimizadas y se ejecuta en código C compilado. Un bucle anidado escrito íntegramente en Python que implemente la misma operación suele ser entre 100 y 1000 veces más lento con matrices grandes. Cuando necesite productos matriciales repetidos en una canalización de datos —transformaciones de características, proyecciones PCA o actualizaciones de pesos— use siempre @ o np.matmul y no implemente el bucle interno por su cuenta.

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

Encadenamiento de varios productos matriciales

Puede encadenar varias operaciones @ en una sola expresión: A @ B @ C se evalúa de izquierda a derecha. NumPy no optimiza automáticamente el orden de multiplicación (a diferencia de mtimes de MATLAB), por lo que, si las matrices tienen tamaños muy diferentes, el orden puede afectar al rendimiento. Para tres o más matrices, considere usar np.linalg.multi_dot([A, B, C]), que selecciona automáticamente la agrupación más 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)

Errores habituales de dimensiones y cómo corregirlos

El error más común al multiplicar matrices es que las dimensiones no coincidan: ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0. Para solucionarlo, compruebe las dimensiones con A.shape y asegúrese de que las dimensiones internas coincidan. Si tiene un vector fila de dimensión (n,) que debe tratarse como un vector columna de dimensión (n, 1), use v.reshape(-1, 1). Si necesita la transpuesta, 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)

Ejemplo práctico: transformación de características

Un caso de uso habitual en ciencia de datos: tiene un conjunto de datos X de dimensión (n_samples, n_features) y una matriz de pesos W de dimensión (n_features, n_outputs). El producto matricial X @ W aplica una transformación lineal a todas las muestras simultáneamente y produce una matriz de dimensión (n_samples, n_outputs). Este es el cálculo central de una capa lineal de una red neuronal y de la predicción mediante regresión lineal.

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)

Comprobación rápida

Compruebe sus conocimientos sobre la multiplicación de matrices con NumPy.

Resumen de la lección

En esta lección ha aprendido que np.matmul y @ implementan una verdadera multiplicación matricial (no elemento a elemento), que las dimensiones internas de las dos matrices deben coincidir y que @ admite la multiplicación por lotes en las dimensiones iniciales. A continuación exploraremos los determinantes, las inversas y las transpuestas: las operaciones que indican si una matriz se puede «deshacer».

Gratis para empezar

Aprende Python con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos
30
Lecciones
120

Preguntas frecuentes

¿La lección «Multiplicación de matrices con np.matmul y @» es gratis?

Sí — el texto completo de «Multiplicación de matrices con np.matmul y @» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Pandas & NumPy Academy, actualiza a CoddyKit PRO. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Multiplicación de matrices con np.matmul y @»?

Multiplique matrices correctamente con np.matmul y el operador @, y distinga * elemento a elemento de la verdadera multiplicación matricial. Practicas Pandas & NumPy Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Pandas & NumPy Academy?

No se requiere experiencia previa. Pandas & NumPy Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Multiplicación de matrices con np.matmul y @»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Pandas & NumPy Academy?

Sí. Cada lección de Pandas & NumPy Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Multiplicación de matrices con np.matmul y @
  2. Determinantes, inversas y transpuestas
  3. Resolución de sistemas lineales
  4. Introducción a valores propios y SVD
← Volver a Pandas & NumPy Academy