Operaciones básicas de NumPy para aprendizaje profundo: +, -, *, /, **, comparaciones, sum/mean/max/min, axis
1. ¿Por qué es importante dominar las operaciones básicas primero?
En aprendizaje profundo, lo que hacemos se reduce a:
- Sumar entradas y pesos (
+) - Multiplicar (
*, multiplicación matricial) - Aplicar funciones no lineales (
**,relu,sigmoid, etc.) - Calcular la pérdida y luego
- Promediar (
mean) o sumar (sum) los valores
Las operaciones de PyTorch siguen el mismo estilo que NumPy, por lo que familiarizarse con NumPy hace que las fórmulas de aprendizaje profundo se vean mucho más claras.
2. Operaciones aritméticas elemento a elemento: +, -, *, /, **
Las operaciones básicas entre arrays de NumPy son elemento a elemento.
import numpy as np
x = np.array([1, 2, 3])
y = np.array([10, 20, 30])
print(x + y) # [11 22 33]
print(x - y) # [ -9 -18 -27]
print(x * y) # [10 40 90]
print(y / x) # [10. 10. 10.]
print(x ** 2) # [1 4 9]
- Arrays 1‑D de igual longitud: operación elemento a elemento
- Arrays 2‑D, 3‑D, etc.: la misma lógica, posición por posición
2.1 Operaciones con escalares
Las operaciones con un escalar también son naturales.
x = np.array([1, 2, 3])
print(x + 10) # [11 12 13]
print(x * 2) # [2 4 6]
print(x / 2) # [0.5 1. 1.5]
Esta “añadir o multiplicar el mismo valor a todos los elementos” se usa con frecuencia en aprendizaje profundo para normalización, escalado y adición de sesgo.
Las tensores de PyTorch funcionan de la misma manera. Expresiones como
x_t + y_t,x_t * 2,x_t ** 2son prácticamente idénticas.
3. Operaciones de comparación: >, <, >=, <=, ==, !=
Al comparar arrays de NumPy, el resultado es un array booleano.
import numpy as np
x = np.array([1, 2, 3, 4, 5])
print(x > 3) # [False False False True True]
print(x == 2) # [False True False False False]
Este array booleano se usa:
- Como máscara para seleccionar elementos
- Para contar cuántos elementos cumplen una condición
Ejemplo:
x = np.array([1, -2, 3, 0, -5, 6])
mask = x > 0
print(mask) # [ True False True False False True]
# Seleccionar solo los positivos
pos = x[mask]
print(pos) # [1 3 6]
# Contar positivos
num_pos = np.sum(mask) # True=1, False=0
print(num_pos) # 3
En aprendizaje profundo se usan patrones similares para:
- Calcular la precisión (accuracy) de predicciones
- Incluir solo posiciones que cumplan una condición en la pérdida
PyTorch sigue el mismo patrón.
4. Funciones de agregación: np.sum, np.mean, np.max, np.min
4.1 Sin axis: cálculo sobre todo el array
La forma básica calcula la suma, media, máximo y mínimo sobre todo el array.
import numpy as np
x = np.array([1, 2, 3, 4])
print(np.sum(x)) # 10
print(np.mean(x)) # 2.5
print(np.max(x)) # 4
print(np.min(x)) # 1
Para arrays de 2‑D o más, el comportamiento es idéntico.
X = np.array([[1, 2, 3],
[4, 5, 6]])
print(np.sum(X)) # 21
print(np.mean(X)) # 3.5
En aprendizaje profundo:
- Media de la pérdida sobre todo el batch o dataset
- Normalización usando media y desviación estándar calculadas sobre todo el dataset
5. Entendiendo el concepto de axis
axis determina sobre qué eje se reduce la operación.
- Sin axis → se reduce sobre todos los elementos
- Con axis → se reduce a lo largo del eje especificado, dejando los demás intactos
5.1 Ejemplo 2‑D
import numpy as np
X = np.array([[1, 2, 3],
[4, 5, 6]]) # shape: (2, 3)
axis=0: cálculo por columnas
print(np.sum(X, axis=0)) # [5 7 9]
print(np.mean(X, axis=0)) # [2.5 3.5 4.5]
- Resultado shape:
(3,) - Se calcula la suma/media de cada columna
- Muy usado para calcular media/desviación estándar por feature
axis=1: cálculo por filas
print(np.sum(X, axis=1)) # [ 6 15]
print(np.mean(X, axis=1)) # [2. 5.]
- Resultado shape:
(2,) - Se calcula la suma/media de cada fila
- Relacionado con la suma/media por muestra
5.2 Ejemplos comunes en aprendizaje profundo
Supongamos que tenemos datos de batch:
# (batch_size, feature_dim)
X = np.random.randn(32, 10) # 32 muestras, 10 características
- Media por feature
mean_per_feature = np.mean(X, axis=0) # shape: (10,)
- Media por muestra
mean_per_sample = np.mean(X, axis=1) # shape: (32,)
5.3 Pensando en axis con un batch de imágenes
Imaginemos un batch de imágenes en estilo PyTorch (N, C, H, W).
# N=32, C=3 (RGB), H=W=64
images = np.random.randn(32, 3, 64, 64)
Ejemplo:
- Máximo de píxeles en todo el batch
global_max = np.max(images) # escalar
- Media por canal (RGB)
channel_mean = np.mean(images, axis=(0, 2, 3)) # shape: (3,)
Este patrón se usa mucho para normalizar por canal.
6. Patrones frecuentes: agregación + comparación
6.1 Cálculo de precisión (accuracy)
Para clasificación binaria:
import numpy as np
# Predicciones (probabilidades 0‑1)
pred = np.array([0.2, 0.8, 0.9, 0.3])
# Etiquetas reales (0 o 1)
target = np.array([0, 1, 1, 0])
# Convertir a clases con umbral 0.5
pred_label = (pred > 0.5).astype(np.int32) # [0 1 1 0]
# Verdaderos positivos
correct = (pred_label == target) # [ True True True True]
accuracy = np.mean(correct) # True=1, False=0
print(accuracy) # 1.0
6.2 Pérdida con máscara
loss = np.array([0.1, 0.5, 0.2, 0.9])
mask = np.array([True, False, True, False])
masked_loss = loss[mask] # [0.1, 0.2]
mean_loss = np.mean(masked_loss)
print(mean_loss) # 0.15000000000000002
7. Resumen: operaciones básicas cubiertas hoy
- Operaciones aritméticas (
+,-,*,/,**) * Elemento a elemento * Compatibles con escalares - Operaciones de comparación (
>,<,>=,<=,==,!=) * Devuelven arrays booleanos * Se usan como máscaras - Funciones de agregación (
np.sum,np.mean,np.max,np.min) * Sin axis: sobre todo el array * Con axis: reducción a lo largo de un eje - Concepto de
axis*axis=0: columnas *axis=1: filas * En aprendizaje profundo: feature‑wise, sample‑wise, channel‑wise
Al dominar estas operaciones, podrás trasladar fórmulas matemáticas a código NumPy/PyTorch de forma natural y eficiente, facilitando la implementación de pérdidas, precisión y normalizaciones.
No hay comentarios.