Tensores: qué son, para qué sirven y cómo operar con ellos
Qué es un tensor (como arreglo n-dimensional y como objeto matemático), para qué sirve, dónde se usa —del deep learning a la física— y las operaciones básicas con NumPy y PyTorch: reshape, broadcasting, reducciones, matmul y einsum.
Xamanek Martínez Marín
Software Engineer & Researcher
Si has usado PyTorch, TensorFlow o JAX, has trabajado con tensores aunque no lo hayas notado: cada imagen, lote de datos, peso de una red neuronal y gradiente es un tensor. La palabra suena intimidante, pero la idea es simple y muy útil. En este artículo vemos qué es un tensor (desde la programación y desde las matemáticas), para qué sirve, dónde se usa y las operaciones básicas que vas a usar todos los días, con ejemplos en NumPy y PyTorch.
1. ¿Qué es un tensor?
1.1 La visión práctica: un arreglo n-dimensional
En programación científica y en machine learning, un tensor es un arreglo de números organizado en n ejes (dimensiones) [1][3]. Lo describen tres propiedades:
- Orden o rango (
ndim): cuántos ejes tiene, es decir, cuántos índices necesitas para llegar a un número. - Forma (
shape): cuántos elementos hay en cada eje. - Tipo de dato (
dtype):float32,int64,bool, etc.
Los objetos de álgebra lineal que ya conoces son casos particulares:
| Orden | Nombre | Ejemplo | Elemento |
|---|---|---|---|
| 0 | Escalar | una temperatura | \(s\) |
| 1 | Vector | las coordenadas de un punto | \(v_i\) |
| 2 | Matriz | una imagen en escala de grises | \(M_{ij}\) |
| 3 | Tensor de orden 3 | una imagen RGB | \(T_{ijk}\) |
| n | Tensor de orden n | un lote de videos | \(T_{i_1 i_2 \dots i_n}\) |
import numpy as np
s = np.array(3.14) # orden 0
v = np.array([1.0, 2.0, 3.0]) # orden 1
M = np.array([[1, 2, 3], [4, 5, 6]]) # orden 2
T = np.arange(24).reshape(2, 3, 4) # orden 3
for nombre, t in [("escalar", s), ("vector", v), ("matriz", M), ("tensor", T)]:
print(f"{nombre:8} ndim={t.ndim} shape={t.shape} dtype={t.dtype}")
escalar ndim=0 shape=() dtype=float64
vector ndim=1 shape=(3,) dtype=float64
matriz ndim=2 shape=(2, 3) dtype=int64
tensor ndim=3 shape=(2, 3, 4) dtype=int64
1.2 La visión matemática: un objeto que no depende de las coordenadas
En física y geometría, "tensor" significa algo más preciso [5]. Un tensor es un objeto multilineal: una función lineal en cada uno de sus argumentos (vectores y covectores), que existe independientemente del sistema de coordenadas. Sus componentes sí dependen de la base, y cambian de una forma muy concreta cuando cambias de coordenadas. Para un tensor de orden 2 con un índice contravariante y uno covariante:
\[T'^{\,i}{}_{j} \;=\; \frac{\partial x'^{\,i}}{\partial x^{k}} \, \frac{\partial x^{l}}{\partial x'^{\,j}} \; T^{k}{}_{l}\]
Esta ley de transformación es lo que distingue a un tensor "de verdad" de una simple tabla de números: si rotas los ejes, el objeto físico (por ejemplo, el esfuerzo dentro de un material) no cambia; solo cambian los números con que lo describes.
En deep learning casi nunca se usa esta ley de transformación: "tensor" se usa como sinónimo de arreglo n-dimensional [1]. Las dos visiones comparten la notación de índices y las operaciones (productos, contracciones), y por eso la segunda ayuda a entender la primera.
2. ¿Para qué sirven?
Los tensores sirven para representar datos que tienen estructura en varios ejes y operar sobre todos a la vez, sin escribir bucles. Por convención, cada eje tiene un significado:
| Dato | Forma típica | Ejes |
|---|---|---|
| Tabla (dataset tabular) | (N, F) |
muestras × características |
| Serie temporal multivariada | (N, T, F) |
muestras × pasos de tiempo × variables |
| Imagen RGB | (H, W, C) |
alto × ancho × canales |
| Lote de imágenes (PyTorch) | (N, C, H, W) |
lote × canales × alto × ancho |
| Video | (N, T, C, H, W) |
lote × cuadros × canales × alto × ancho |
| Texto tokenizado con embeddings | (N, L, D) |
lote × tokens × dimensión del embedding |
Por ejemplo, un lote de 32 fotos RGB de 224×224 píxeles es un solo tensor de forma (32, 3, 224, 224), con unos 4.8 millones de números. Una capa convolucional recibe ese tensor completo y devuelve otro. Al representar todo así, las bibliotecas pueden aprovechar instrucciones vectorizadas de la CPU y miles de núcleos de GPU/TPU [3][4].
3. ¿Dónde se usan?
- Deep learning. PyTorch, TensorFlow (de ahí su nombre) y JAX están construidos alrededor de un tipo tensor con diferenciación automática: entradas, pesos, activaciones y gradientes son tensores [1][4].
- Visión por computadora y procesamiento de lenguaje natural. Imágenes, mapas de características, secuencias de tokens y los mecanismos de atención de los transformers son operaciones entre tensores.
- Física e ingeniería. El tensor de esfuerzos de Cauchy describe las fuerzas internas de un sólido, el tensor de inercia relaciona velocidad angular y momento angular, y el tensor métrico \(g_{\mu\nu}\) de la relatividad general describe la curvatura del espacio-tiempo [5].
- Análisis de datos multidimensionales. Datos como usuario × producto × tiempo o paciente × gen × condición se modelan como tensores. Las descomposiciones tensoriales (CP, Tucker), que generalizan la SVD de matrices, encuentran en ellos patrones latentes; se usan en sistemas de recomendación, quimiometría y neurociencia [2].
- Computación científica. Simulación numérica, procesamiento de señales y gráficos 3D (transformaciones homogéneas por lotes).
4. Operaciones básicas con tensores
Los ejemplos usan NumPy [3]; cada sección incluye su equivalente en PyTorch [4], cuya API es casi idéntica (np.array ↔ torch.tensor, axis ↔ dim).
4.1 Creación
import numpy as np
import torch
np.zeros((2, 3)) # tensor de ceros
np.ones((2, 3, 4)) # tensor de unos
np.arange(24).reshape(2, 3, 4)
np.random.default_rng(0).normal(size=(3, 3)) # valores aleatorios N(0, 1)
torch.zeros(2, 3)
torch.arange(24).reshape(2, 3, 4)
torch.randn(3, 3)
torch.from_numpy(np.ones(3)) # comparte memoria con el arreglo de NumPy
4.2 Indexado y rebanado (slicing)
Un índice por eje; : toma el eje completo y ... completa los ejes restantes.
T = np.arange(24).reshape(2, 3, 4)
print(T[1]) # el segundo "bloque" 3x4
print(T[0, :, 1]) # bloque 0, todas las filas, columna 1
print(T[..., -1]) # última columna de cada bloque
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]
[1 5 9]
[[ 3 7 11]
[15 19 23]]
4.3 Cambiar la forma: reshape, transpose y permute
reshape reorganiza los mismos datos en otra forma; el número total de elementos se conserva y -1 significa "lo que haga falta". transpose reordena los ejes.
x = np.arange(12)
A = x.reshape(3, 4)
print(A)
print(A.T.shape) # transpuesta: (4, 3)
B = x.reshape(2, 3, 2)
print(np.transpose(B, (2, 0, 1)).shape) # reordenar ejes
print(x.reshape(-1, 6).shape) # -1 se infiere
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
(4, 3)
(2, 2, 3)
(2, 6)
En PyTorch: t.reshape(3, 4), t.T, t.permute(2, 0, 1) y t.view(...), que exige memoria contigua. El caso típico es pasar una imagen (H, W, C) al formato (C, H, W) que esperan las convoluciones: img.permute(2, 0, 1).
4.4 Operaciones elemento a elemento y broadcasting
Las operaciones aritméticas (+, -, *, /, **, np.exp, …) se aplican elemento a elemento. Cuando las formas no coinciden, entra en juego el broadcasting: se comparan las formas desde el último eje, y dos ejes son compatibles si son iguales o si uno de ellos vale 1. El eje de tamaño 1 se "estira" virtualmente, sin copiar datos [3].
A = np.array([[1, 2, 3], [4, 5, 6]]) # (2, 3)
print(A * 10) # escalar con tensor
print(A + np.array([100, 200, 300])) # (2, 3) + (3,) -> por filas
print(A + np.array([[1000], [2000]])) # (2, 3) + (2, 1) -> por columnas
[[10 20 30]
[40 50 60]]
[[101 202 303]
[104 205 306]]
[[1001 1002 1003]
[2004 2005 2006]]
El broadcasting aparece todo el tiempo en la práctica: sumar el sesgo de una capa a todo un lote, o normalizar un dataset restando la media de cada columna (X - X.mean(axis=0)).
4.5 Reducciones por eje
Una reducción (sum, mean, max, argmax, std, …) elimina un eje combinando sus elementos. El parámetro axis (o dim en PyTorch) indica cuál.
A = np.array([[1, 2, 3], [4, 5, 6]])
print(A.sum()) # todos los elementos
print(A.sum(axis=0)) # colapsa filas -> una suma por columna
print(A.mean(axis=1)) # colapsa columnas -> una media por fila
print(A.max(axis=1), A.argmax(axis=1))
21
[5 7 9]
[2. 5.]
[3 6] [2 2]
Un caso muy común: logits.argmax(dim=1) convierte las salidas de un clasificador (N, clases) en la clase predicha para cada muestra. Con keepdims=True (keepdim=True en PyTorch) el eje reducido se conserva con tamaño 1, lo que facilita el broadcasting posterior.
4.6 Producto punto y multiplicación de matrices
El producto punto de dos vectores y el producto matricial contraen un índice:
\[a \cdot b = \sum_{i} a_i\, b_i, \qquad (AB)_{ik} = \sum_{j} A_{ij}\, B_{jk}\]
a = np.array([1, 2, 3]); b = np.array([4, 5, 6])
print(np.dot(a, b)) # 1·4 + 2·5 + 3·6
A = np.array([[1, 2], [3, 4]]); B = np.array([[5, 6], [7, 8]])
print(A @ B) # producto matricial (no elemento a elemento)
X = np.ones((32, 10, 4)); W = np.ones((4, 8))
print((X @ W).shape) # matmul por lotes + broadcasting
32
[[19 22]
[43 50]]
(32, 10, 8)
Ojo: A * B es el producto elemento a elemento (de Hadamard) y A @ B es el matricial; confundirlos es uno de los errores más comunes. Con más de dos ejes, @ multiplica las dos últimas dimensiones y aplica broadcasting al resto. Así funciona una capa densa sobre un lote de secuencias: (32, 10, 4) @ (4, 8) → (32, 10, 8).
En PyTorch: torch.dot, A @ B, torch.matmul y torch.bmm (lotes explícitos).
4.7 Producto exterior (tensorial)
El producto exterior hace lo contrario de una contracción: suma órdenes. Dos vectores (orden 1) dan una matriz (orden 2):
\[(a \otimes b)_{ij} = a_i\, b_j\]
print(np.outer(a, b))
print(np.tensordot(a, b, axes=0).shape) # generalización a cualquier orden
[[ 4 5 6]
[ 8 10 12]
[12 15 18]]
(3, 3)
4.8 Contracción y einsum: la navaja suiza
Casi todas las operaciones anteriores son casos particulares de una sola idea: multiplicar componentes y sumar sobre índices repetidos. Es la convención de suma de Einstein: un índice que aparece dos veces se suma implícitamente.
\[C_{ik} = A_{ij}\, B_{jk} \;\equiv\; \sum_{j} A_{ij}\, B_{jk}, \qquad \operatorname{tr}(A) = A_{ii}\]
np.einsum y torch.einsum implementan esta notación con una cadena: los índices de entrada, ->, y los de salida. Los índices que no aparecen en la salida se suman.
A = np.arange(6).reshape(2, 3); B = np.arange(12).reshape(3, 4)
print(np.allclose(np.einsum("ij,jk->ik", A, B), A @ B)) # producto matricial
print(np.einsum("ii->", np.array([[1, 2], [3, 4]]))) # traza: 1 + 4
print(np.einsum("ij->ji", A).shape) # transpuesta
# Puntajes de atención: lote b, consultas q, claves k, dimensión d
Q = np.ones((2, 5, 16)); K = np.ones((2, 7, 16))
print(np.einsum("bqd,bkd->bqk", Q, K).shape)
True
5
(3, 2)
(2, 5, 7)
La última línea calcula \(Q K^\top\) para cada elemento del lote, el núcleo del mecanismo de atención de los transformers, en una sola expresión legible. Con einsum el código queda escrito igual que la fórmula del artículo.
4.9 Concatenar y apilar
concatenate (torch.cat) une tensores a lo largo de un eje existente; stack crea un eje nuevo.
x = np.zeros((3, 4)); y = np.ones((3, 4))
print(np.concatenate([x, y], axis=0).shape) # una debajo de otra
print(np.concatenate([x, y], axis=1).shape) # lado a lado
print(np.stack([x, y]).shape) # nuevo eje al frente
(6, 4)
(3, 8)
(2, 3, 4)
4.10 Normas
La norma mide el "tamaño" de un tensor. La euclidiana (\(L_2\)) y la \(L_1\) son las más usadas, por ejemplo en regularización y en el recorte de gradientes:
\[\lVert v \rVert_2 = \sqrt{\textstyle\sum_i v_i^2}, \qquad \lVert v \rVert_1 = \textstyle\sum_i \lvert v_i \rvert\]
v = np.array([3.0, 4.0])
print(np.linalg.norm(v), np.linalg.norm(v, ord=1))
5.0 7.0
Para una matriz, np.linalg.norm(A) da por defecto la norma de Frobenius: la \(L_2\) de todos sus elementos.
4.11 Bonus: tensores que recuerdan cómo se calcularon
Lo que separa a un tensor de PyTorch de un arreglo de NumPy es la diferenciación automática [4]. Si marcas un tensor con requires_grad=True, PyTorch registra las operaciones que se le aplican y puede calcular gradientes con backward(). Así se entrenan las redes neuronales.
import torch
w = torch.tensor([2.0, -1.0], requires_grad=True)
x = torch.tensor([3.0, 4.0])
y = (w * x).sum() ** 2 # y = (w·x)^2 = (6 - 4)^2 = 4
y.backward() # dy/dw = 2 (w·x) x = 2 · 2 · x
print(y.item())
print(w.grad)
4.0
tensor([12., 16.])
Además, t.to("cuda") mueve el tensor a la GPU, y a partir de ahí todas las operaciones anteriores se ejecutan en paralelo sin cambiar el código.
5. Resumen
- Un tensor es, en la práctica, un arreglo n-dimensional con orden, forma y tipo de dato. En física es además un objeto multilineal que no depende de las coordenadas.
- Sirve para representar datos con estructura (tablas, imágenes, video, texto) y operar sobre ellos sin bucles, aprovechando CPU vectorizada y GPU.
- Se usa en deep learning, visión y lenguaje natural, física e ingeniería y análisis de datos multidimensionales.
- Las operaciones básicas son: creación, indexado, cambio de forma, elemento a elemento con broadcasting, reducciones por eje, matmul, producto exterior, contracción con
einsum, concatenar/apilar y normas.
Si dominas estas operaciones, puedes leer y escribir casi cualquier modelo moderno: una red neuronal es, en el fondo, una secuencia de estas operaciones aplicadas a tensores.
Lecturas recomendadas
El capítulo 2 de Deep Learning [1] es la mejor introducción al álgebra lineal que necesita el aprendizaje automático. Kolda y Bader [2] es la referencia sobre descomposiciones tensoriales. Harris et al. [3] y Paszke et al. [4] explican el diseño de NumPy y PyTorch. Borisenko y Tarapov [5] son un clásico accesible sobre la visión física y geométrica de los tensores.
Referencias
-
[1]
Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep Learning. MIT Press. (Cap. 2: Álgebra lineal).
-
[2]
Kolda, T. G., & Bader, B. W. (2009). Tensor decompositions and applications. SIAM Review, 51(3), 455–500.
DOI: 10.1137/07070111X
-
[3]
Harris, C. R., Millman, K. J., van der Walt, S. J., et al. (2020). Array programming with NumPy. Nature, 585, 357–362.
DOI: 10.1038/s41586-020-2649-2
-
[4]
Paszke, A., Gross, S., Massa, F., et al. (2019). PyTorch: An imperative style, high-performance deep learning library. Advances in Neural Information Processing Systems 32 (NeurIPS 2019).
-
[5]
Borisenko, A. I., & Tarapov, I. E. (1968). Vector and Tensor Analysis with Applications (R. A. Silverman, Trans.). Dover.
Comentarios
Inicia sesión o crea una cuenta para comentar.
Todavía no hay comentarios aprobados para este post.