NumPy para principiantes en Deep Learning: ¿Por qué debes aprenderlo antes que PyTorch?
¿Por qué los principiantes en Deep Learning deberían empezar por NumPy?
En la mayoría de los libros y cursos de Deep Learning, los frameworks como PyTorch o TensorFlow aparecen primero. Cuando intentas construir un modelo, a menudo surge la sensación de:
- "¿Qué es un tensor?"
- "¿Por qué me da un error de shape?"
- "Pensé que podía combinar los batches de esa manera…"
Estas confusiones suelen surgir cuando se pasa directamente a un framework sin comprender bien NumPy.
- El
Tensorde PyTorch es casi idéntico alndarrayde NumPy. - El preprocesamiento de datos, la creación de batches y los cálculos estadísticos siguen la lógica de pensar en NumPy.
Por eso, si quieres aprender Deep Learning de verdad, NumPy es prácticamente la base esencial.
¿Qué es NumPy?
NumPy (Numerical Python) es una librería que permite realizar cálculos numéricos de forma rápida en Python.
Palabras clave:
- Array multidimensional (
ndarray): la base para vectores, matrices y tensores. - Operaciones vectorizadas: sin bucles
for, se procesan grandes cantidades de datos de una vez. - Broadcasting: permite operar entre arrays de formas distintas de manera inteligente.
- Operaciones lineales: multiplicación de matrices, transposición, inversa, etc.
- Módulo de aleatorios: muestreo, distribuciones normales, inicialización aleatoria.
Casi todas las ecuaciones de Deep Learning se reducen a operaciones con vectores y matrices, por lo que NumPy es el lenguaje que facilita su manejo.
Listas de Python vs. Arrays de NumPy
Primero, veamos una comparación rápida entre listas de Python y arrays de NumPy.
# Lista básica de Python
a = [1, 2, 3, 4]
b = [10, 20, 30, 40]
# Suma de listas
print(a + b)
# Resultado: [1, 2, 3, 4, 10, 20, 30, 40] (concatenación)
El operador + de las listas concatena, no suma elemento a elemento.
import numpy as np
a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])
print(a + b)
# Resultado: [11 22 33 44] (suma elemento a elemento)
El + de NumPy realiza la operación element-wise que esperamos en matemáticas. Los Tensor de los frameworks siguen exactamente este estilo.
Vectorización: reducir bucles y escribir código como fórmulas
En Deep Learning se recomienda minimizar los bucles for. En su lugar, se usa la vectorización.
Ejemplo: elevar al cuadrado cada elemento.
Python + bucle for
data = [1, 2, 3, 4, 5]
squared = []
for x in data:
squared.append(x ** 2)
print(squared) # [1, 4, 9, 16, 25]
Vectorización con NumPy
import numpy as np
data = np.array([1, 2, 3, 4, 5])
squared = data ** 2
print(squared) # [ 1 4 9 16 25]
- Código más corto.
- Más cercano a una expresión matemática.
- Implementado en C, por lo que es mucho más rápido.
Las operaciones de tensores en PyTorch y TensorFlow siguen exactamente este estilo vectorizado.
Broadcasting: operar con formas distintas
El broadcasting es la regla que permite que arrays de tamaños diferentes se operen automáticamente.
Ejemplo: añadir una constante a cada muestra.
import numpy as np
x = np.array([[1, 2, 3],
[4, 5, 6]]) # shape: (2, 3)
b = np.array([10, 20, 30]) # shape: (3,)
y = x + b
print(y)
# [[11 22 33]
# [14 25 36]]
NumPy expande b a (1, 3) y luego a (2, 3) para la operación.
En PyTorch funciona igual:
import torch
x = torch.tensor([[1, 2, 3],
[4, 5, 6]])
b = torch.tensor([10, 20, 30])
y = x + b
print(y)
Comprender el broadcasting en NumPy facilita el trabajo con tensores en PyTorch.
Vectores, matrices y tensores: expresiones de Deep Learning con NumPy
Conceptos comunes en Deep Learning vistos con NumPy:
- Vector: array 1D →
shape: (N,) - Matriz: array 2D →
shape: (M, N) -
Tensor: array 3D o más
-
Ejemplo: lote de imágenes
batch_size = 32, imágenes en escala de grises 28x28 →shape: (32, 28, 28)
Ejemplo de multiplicación de matrices simple:
import numpy as np
# Vector de entrada (3 características)
x = np.array([1.0, 2.0, 3.0]) # shape: (3,)
# Matriz de pesos (entrada 3 → salida 2)
W = np.array([[0.1, 0.2, 0.3],
[0.4, 0.5, 0.6]]) # shape: (2, 3)
# Producto: y = W @ x
y = W @ x
print(y) # [1.4 3.2]
Esto es esencialmente el cálculo de una capa lineal de una sola capa. En PyTorch:
import torch
x = torch.tensor([1.0, 2.0, 3.0]) # shape: (3,)
W = torch.tensor([[0.1, 0.2, 0.3],
[0.4, 0.5, 0.6]]) # shape: (2, 3)
y = W @ x
print(y)
La forma y el significado son prácticamente idénticos. Familiarizarse con las operaciones de matrices en NumPy es equivalente a aprender a leer fórmulas de Deep Learning.
¿Cómo se conectan NumPy y PyTorch?
1. Tensor y ndarray son “primos”
- Ambos son arrays n‑dimensionales con operaciones vectorizadas.
- Funciones como
shape,reshape,transpose,sum,meantienen nombres y comportamientos muy similares.
Por eso muchos usan NumPy como un entrenamiento para entender los tensores de PyTorch.
2. Preprocesamiento de datos suele ser NumPy‑style
Tareas comunes en proyectos de Deep Learning:
- Leer CSV, imágenes, logs, etc.
- Convertir a valores numéricos.
- Normalizar, estandarizar, hacer slicing, mezclar (shuffle), dividir en batches.
Estas tareas se realizan con NumPy + pandas en la mayoría de los casos.
import numpy as np
import torch
# Preparar datos en NumPy
np_data = np.random.randn(100, 3) # 100 muestras, 3 características
# Convertir a tensor de PyTorch
tensor_data = torch.from_numpy(np_data).float()
print(tensor_data.shape) # torch.Size([100, 3])
Al revés, convertir tensores de PyTorch a NumPy también es frecuente:
y = tensor_data.mean(dim=0) # tensor de PyTorch
y_np = y.detach().cpu().numpy()
En la práctica, NumPy y PyTorch se alternan constantemente.
3. Cálculo en GPU vs. práctica conceptual
- Los tensores de PyTorch se ejecutan en GPU (CUDA) y soportan autograd.
- NumPy es CPU‑based, pero es mucho más simple para practicar y depurar.
Por eso la estrategia habitual es:
- Probar ideas y fórmulas en NumPy.
- Cuando estén validadas, trasladarlas a PyTorch.
Patrones comunes de NumPy en Deep Learning
1. Inicialización aleatoria y ruido
import numpy as np
# Inicialización de pesos (distribución normal)
W = np.random.randn(3, 3) * 0.01
# Añadir ruido a la entrada
x = np.array([1.0, 2.0, 3.0])
noise = np.random.normal(0, 0.1, size=x.shape)
x_noisy = x + noise
2. Normalización de datos (media 0, desviación 1)
X = np.random.randn(100, 3) * 10 + 50 # datos ficticios
mean = X.mean(axis=0)
std = X.std(axis=0)
X_norm = (X - mean) / (std + 1e-8)
Esta normalización afecta significativamente el rendimiento y la estabilidad del entrenamiento.
3. One‑hot encoding
num_classes = 4
labels = np.array([0, 2, 1, 3]) # índices de clase
one_hot = np.eye(num_classes)[labels]
print(one_hot)
# [[1. 0. 0. 0.]
# [0. 0. 1. 0.]
# [0. 1. 0. 0.]
# [0. 0. 0. 1.]]
PyTorch usa la misma lógica.
4. División en batches
X = np.random.randn(100, 3)
batch_size = 16
for i in range(0, len(X), batch_size):
batch = X[i:i+batch_size]
# Aquí se pasaría el batch al modelo
Este patrón se conecta directamente con el concepto de DataLoader en PyTorch.
Puntos clave al estudiar NumPy para Deep Learning
No necesitas dominar todas las funciones, solo los siguientes conceptos:
ndarraybásico:np.array,dtype,shape,reshape,astype.- Indexación y slicing:
x[0],x[1:3],x[:, 0],x[:, 1:3],x[x > 0]. - Operaciones básicas:
+,-,*,/,**, comparaciones,np.sum,np.mean,axis. - Lineal algebra: producto
@onp.dot, transposiciónx.T. - Broadcasting: operaciones con
(N, D) + (D,),(N, 1). - Funciones aleatorias:
np.random.randn,np.random.randint,np.random.permutation. - Conexión con PyTorch:
torch.from_numpy,tensor.numpy().
Dominar estos puntos hará que las operaciones de tensores en PyTorch se sientan naturales.
Conclusión: NumPy es el “libro de gramática” de Deep Learning
En resumen:
- NumPy es una librería de cálculo numérico con arrays multidimensionales.
- Los
Tensorde PyTorch son esencialmente la versión de Deep Learning dendarray. - Aprender vectorización, broadcasting y álgebra lineal con NumPy:
- Reduce errores de shape.
- Facilita la traducción de fórmulas de papers a código.
- Mejora tus habilidades de pre‑procesamiento y análisis de datos.
Si buscas entender Deep Learning desde la perspectiva matemática y de operaciones con arrays, NumPy es el punto de partida ideal.
No hay comentarios.