Una imagen es una matriz

Una imagen en escala de grises es esencialmente un arreglo NumPy bidimensional. Al aplicar transposición, volteo, recorte o convolución a la matriz, la imagen cambia en consecuencia.

Después de completar este caso de estudio, entenderás:La base del procesamiento de imágenes es el álgebra lineal; una matriz es una tabla de números.


Introducción desde la vida cotidiana

Los cuadros de píxeles de una fotografía

Amplía una foto de tu teléfono, y amplíala más, hasta que puedas ver pequeños cuadrados. Cada cuadrado tiene un único valor de color: 0 representa negro puro, 255 blanco puro, y los números intermedios son diferentes tonos de gris.

Toda la foto es un arreglo rectangular de estos pequeños cuadrados: lo que los matemáticos llaman «matriz»」。


Comprensión intuitiva

Una matriz no es un concepto profundo: es simplemente una tabla llena de números.

Por ejemplo, esta matriz \(3 \times 3\), donde cada número representa el brillo de un píxel (0 es el más oscuro, 1 el más brillante):

Imagen en escala de grises 3x3 Una matriz, 9 números
\[ M = \begin{bmatrix} 0.0 & 0.5 & 1.0 \\ 0.3 & 0.7 & 0.6 \\ 0.8 & 0.2 & 0.4 \end{bmatrix} \]

Con esta idea en mente, las diversas operaciones del procesamiento de imágenes resultan evidentes:

Transposición
img.T
Voltear a lo largo de la diagonal
Espejo horizontal
img[:, ::-1]
Voltear de izquierda a derecha
Espejo vertical
img[::-1, :]
Voltear de arriba hacia abajo
Recorte
img[10:54, 10:54]
Extraer una subregión
Desenfoque
Media móvil con núcleo de convolución
Promedio de la vecindad
Rotación
Transformación de coordenadas
Multiplicación de matrices

Cuando haces clic en un botón en Photoshop, detrás de escena NumPy está operando sobre un arreglo bidimensional.


Definición matemática

Una imagen en escala de grises de \(H \times W\) se puede representar como una matriz de números reales:

\[ M \in \mathbb{R}^{H \times W}, \quad M_{ij} \in [0, 1] \]

donde \(M_{ij}\) representa el valor de brillo del píxel en la fila \(i\), columna \(j\).

Conceptos clave de las operaciones con matrices:

OperaciónExpresión matemáticaNotación en NumPyEfecto en la imagen
Transposición\(M^T_{ij} = M_{ji}\)img.TIntercambiar filas y columnas, voltear a lo largo de la diagonal
Volteo horizontal\(M'_{ij} = M_{i, W-1-j}\)img[:, ::-1]Invertir el índice de las columnas
Volteo vertical\(M'_{ij} = M_{H-1-i, j}\)img[::-1, :]Invertir el índice de las filas
Desenfoque promedio\(M'_{ij} = \frac{1}{k^2}\sum_{p,q} M_{i+p, j+q}\)Ventana deslizante calculando mean()Reemplazar cada píxel por el promedio de su vecindad

La operación de «ventana deslizante» utilizada en el desenfoque promedio es, en esencia, el germen de laconvolución— la operación central de las redes neuronales convolucionales (CNN).


Práctica con Python

Genera una imagen sintética en escala de grises y utiliza operaciones de arreglos NumPy para implementar transposición, volteo, recorte y desenfoque por convolución escrito a mano.

Ejemplo

import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import os

# Crear el directorio de salida
OUT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "outputs")
os.makedirs(OUT, exist_ok=True)

# 1. Generar una imagen sintética en escala de grises: gradiente diagonal + cuadrado brillante en el centro
size = 64
img = np.zeros((size, size))
for i in range(size):
    for j in range(size):
        img[i, j] = (i + j) / (2 * size)  # Gradiente diagonal de oscuro a claro
img[20:44, 20:44] += 0.6                  # Agregar un cuadrado brillante en el centro
img = np.clip(img, 0, 1)                  # Limitar al rango [0, 1]

print("EJEMPLO Forma de la matriz de imagen (shape):", img.shape)
print("Primeros 3x3 de la matriz de imagen:"\n", np.round(img[:3, :3], 3))

# 2. Operaciones con matrices = transformación de imágenes
img_transpose = img.T           # Transposición: intercambiar filas y columnas
img_flip_lr = img[:, ::-1]      # Espejo horizontal: invertir índices de columnas
img_flip_ud = img[::-1, :]      # Espejo vertical: invertir índices de filas
img_crop = img[10:54, 10:54]    # Recorte: usar segmentos (slices) para obtener una submatriz

# 3. Desenfoque promedio escrito a mano (núcleo de convolución 5x5, sin usar OpenCV)
def box_blur(mat, k=5):
    """Aplicar desenfoque promedio a la matriz con una ventana deslizante de k x k"""
    pad = k // 2
    # Rellenar los bordes con valores de borde (edge padding)
    padded = np.pad(mat, pad, mode="edge")
    out = np.zeros_like(mat)
    for i in range(mat.shape[0]):
        for j in range(mat.shape[1]):
            # Tomar la vecindad de k x k y calcular el promedio
            out[i, j] = padded[i:i+k, j:j+k].mean()
    return out

img_blur = box_blur(img, k=5)
print("EJEMPLO Primeros 3x3 de la matriz después del desenfoque:"\n",
      np.round(img_blur[:3, :3], 3))

# 4. Guardar el gráfico comparativo de visualización
fig, axes = plt.subplots(2, 3, figsize=(12, 8))
titles = ["Imagen original (matriz)", "Transposición img.T",
          "Espejo horizontal img[:, ::-1]",
          "Espejo vertical img[::-1, :]",
          "Recorte img[10:54, 10:54]",
          "Desenfoque promedio (convolución 5x5)"]
images = [img, img_transpose, img_flip_lr,
          img_flip_ud, img_crop, img_blur]

for ax, title, im in zip(axes.flat, titles, images):
    ax.imshow(im, cmap="gray", vmin=0, vmax=1)
    ax.set_title(title, fontsize=11)
    ax.axis("off")

plt.tight_layout()
plt.savefig(os.path.join(OUT, "01_image_as_matrix.png"), dpi=130)
print(f"\n"EJEMPLO El resultado de la visualización se ha guardado en {OUT}/01_image_as_matrix.png")
EJEMPLO 图像矩阵形状 (shape): (64, 64)
图像矩阵前 3x3 部分:
 [[0.    0.008 0.016]
 [0.008 0.016 0.023]
 [0.016 0.023 0.031]]
EJEMPLO 模糊后矩阵前 3x3 部分:
 [[0.009 0.011 0.013]
 [0.01  0.013 0.016]
 [0.011 0.016 0.021]]
EJEMPLO 可视化结果已保存到 .../outputs/01_image_as_matrix.png

Se puede ver que, después del desenfoque, las diferencias de valores entre píxeles adyacentes se reducen — esta es precisamente la esencia matemática del «desenfoque»:Reemplazar el valor del píxel original por el promedio de su vecindad。


Casos de uso en IA

Escenario de IACómo se utilizan las matrices
Red neuronal convolucional (CNN)La entrada es un tensor de orden 4 formado por un lote de imágenes (batch, H, W, C); cada capa desliza núcleos de convolución (pequeñas matrices) sobre la entrada.
Aumento de datos (Augmentation)Durante el entrenamiento, se voltean, rotan y recortan imágenes aleatoriamente — todo son operaciones matriciales para ampliar el conjunto de entrenamiento.
Preprocesamiento de imágenesAntes de enviarlas al modelo, se recortan uniformemente a un tamaño fijo (por ejemplo, 224x224) — es decir, segmentación (slicing) y escalado de matrices.
Transferencia de estiloRepresentar la imagen como una matriz de características y alterar las características de «estilo» mediante operaciones matriciales.

El ndarray de NumPy y el Tensor de PyTorch son, en esencia, la misma cosa: una tabla multidimensional de números. Si entiendes las matrices, entiendes la estructura de datos más básica de los marcos de aprendizaje profundo.

Otras extensiones