Compresión de imágenes con SVD en Python

Clase 12 de 12 • Curso Avanzado de Álgebra Lineal y Machine Learning: PCA y SVD

Resumen

La descomposición en valores singulares (SVD) permite comprimir imágenes sin perder la esencia visual. Al conservar solo las componentes más importantes, se reduce drásticamente la información almacenada y se mantiene la estructura clave: formas y contrastes. Aquí verás cómo aplicarlo en Google Colab con NumPy, Matplotlib y scikit-image, y por qué esto acelera el procesamiento y el entrenamiento de modelos.

¿Qué es SVD y por qué comprime imágenes?

Una imagen se trata como una matriz de píxeles. SVD la descompone en U, sigma y Vt. La matriz sigma contiene los valores singulares ordenados por importancia. Las primeras componentes capturan la estructura principal; las últimas suelen ser ruido o detalles muy finos.

La compresión consiste en descartar los valores singulares pequeños y reconstruir la imagen con los más altos. El resultado: una imagen casi idéntica con mucho menos almacenamiento. Para este flujo, se trabaja en escala de grises: primero se transforma la imagen a grises y luego se aplica SVD.

¿Cómo se prepara la imagen en Google Colab?

Importar librerías de NumPy, Matplotlib y scikit-image.
Cargar el dataset de ejemplo: la imagen «rocket».
Convertir a escala de grises con rgb2gray.
Redimensionar con resize para procesar más rápido.

import numpy as np
import matplotlib.pyplot as plt
from skimage import data
from skimage.transform import resize
from skimage.color import rgb2gray

imagen_original = rgb2gray(data.rocket())
imagen = resize(imagen_original, (300, 200))

¿Cómo se descompone y se reconstruye con k valores?

Aplicar SVD: u, s, vt = np.linalg.svd(imagen).
Tomar solo las primeras k componentes.
Reconstruir: Uk @ Sk @ Vtk.

u, s, vt = np.linalg.svd(imagen)

def reconstruir_con_k(k):
    u_k = u[:, :k]
    s_k = np.diag(s[:k])
    vt_k = vt[:k, :]
    imagen_reconstruida = u_k @ s_k @ vt_k
    return imagen_reconstruida

k_valores = [5, 20, 50]
imagenes_reconstruidas = [reconstruir_con_k(k) for k in k_valores]

¿Cómo visualizar la original y las reconstrucciones?

Crear subplots en una fila.
Mostrar la imagen original y las reconstruidas con imshow.
Titular cada panel con una f-string indicando k.

fig, axes = plt.subplots(1, 4, figsize=(20, 5))
axes[0].imshow(imagen, cmap='gray')
axes[0].set_title('Original')

for i, k in enumerate(k_valores):
    axes[i + 1].imshow(imagenes_reconstruidas[i], cmap='gray')
    axes[i + 1].set_title(f'Reconstrucción con k={k}')

plt.show()

¿Cómo implementarlo en Python con NumPy y scikit-image?

El flujo es claro: preparar datos, descomponer, reconstruir y visualizar. Con una simple función, puedes ajustar k para explorar el compromiso entre calidad y compresión. Una list comprehension facilita generar múltiples reconstrucciones de forma compacta y legible.

U almacena combinaciones de píxeles por filas.
Vt captura combinaciones por columnas.
Sigma prioriza qué tanto aporta cada componente.
Con k pequeño: fuerte compresión y más borrosidad.
Con k mayor: más detalle, más costo de almacenamiento.

¿Qué resultados y beneficios se observan al variar k?

En la demostración con k = 5, 20 y 50: - Con 5: la imagen se ve borrosa, difícil de distinguir el cohete. - Con 20: ya se reconoce claramente el cohete. - Con 50: la similitud con la original es prácticamente idéntica.

¿Qué tamaños de matrices devuelve SVD?

Imagen redimensionada de 300 por 200: 60,000 números.
U con forma 300 por 300: matriz cuadrada.
Sigma con 200 valores singulares: uno por cada columna de la imagen.
Vt con forma 200 por 200: matriz cuadrada.

¿Qué mejoras trae para el entrenamiento?

Menos características por imagen: de 60,000 píxeles a 50 valores singulares.
Entrenamiento mucho más rápido: el modelo procesa datos compactos que capturan la esencia.
Mejor generalización: aprende la estructura fundamental en lugar del ruido.

¿Cómo ayuda al denoising?

Los últimos valores singulares capturan ruido: grano e imperfecciones del sensor.
Al reconstruir con menos componentes, se filtra el ruido automáticamente.
El resultado es más limpio y útil para tareas de visión.
Beneficios clave.
Eficiencia en almacenamiento y velocidad de carga.
Aceleración del entrenamiento con menos dimensiones.
Reducción de ruido y mejor calidad de señal.

¿Te animas a experimentar? Vuelve a ejecutar el código y prueba con distintos k: comparte cuál es el mínimo k con el que aún reconoces claramente la imagen y sube tu captura en los comentarios.

Bryan Castano

student•

Hola Chicos, Yo os comparto algunas notas y outputs de mi tutot de LinAlg "Gemini" que es genial en su modo "learning".

Si el Eigendecomposition Av = lambda .v es como entender el ADN de una matriz cuadrada, la Descomposición en Valores Singulares (SVD) es como hacerle una radiografía completa a cualquier matriz, sea cuadrada o no.

La SVD establece que cualquier matriz $A$ de dimensiones $m x n$ puede ser factorizada en el producto de tres matrices especiales:

$$A = U \Sigma V^T$$

Donde:

$U$ ($m \times m$): Es una matriz ortogonal ($U^T U = I$). Sus columnas son los vectores singulares izquierdos. Representan una rotación en el espacio de llegada.
$\Sigma$ ($m \times n$): Es una matriz diagonal (no necesariamente cuadrada). Sus elementos en la diagonal son los valores singulares $\sigma_1 > \sigma_2 > ... > 0$. Indican cuánto se estira la matriz en cada dirección.
$V^T$ ($n x n$): Es la transpuesta de otra matriz ortogonal. Sus columnas son los vectores singulares derechos. Representan una rotación inicial en el espacio de partida.

Compresión de Datos: Los valores singulares en $\Sigma$ están ordenados por importancia. Si te quedas solo con los primeros $k$ valores (los más grandes), puedes reconstruir una aproximación muy cercana a la original usando mucho menos espacio.
PCA (Análisis de Componentes Principales): El PCA, que usas para reducir dimensiones en Machine Learning, es básicamente SVD aplicado a una matriz de datos centrada.
Sistemas de Recomendación: Algoritmos como los que usa Netflix para predecir qué película te gustará se basan en SVD para encontrar "factores latentes" entre usuarios y películas.

@Aqui un script de ejempl oque Gemini me ha dado :

import numpy as np
import matplotlib.pyplot as plt

def svd_compression_demo():
    # 1. Crear una matriz de 100x100 con un patrón (nuestra "imagen")
    # Usamos un producto exterior para crear una matriz de bajo rango
    x = np.linspace(-5, 5, 100)
    y = np.linspace(-5, 5, 100)
    X, Y = np.meshgrid(x, y)
    A = np.sin(X) + np.cos(Y) # Un patrón complejo

    # 2. Aplicar SVD
    # U: Vectores izquierdos, s: Valores singulares, Vt: Vectores derechos
    U, s, Vt = np.linalg.svd(A)

    # 3. Reconstrucción con diferentes rangos (k)
    # k es el número de valores singulares que decidimos mantener
    ranks = [2, 5, 10, 50]
    
    plt.figure(figsize=(12, 8))
    
    # Imagen Original
    plt.subplot(2, 3, 1)
    plt.imshow(A, cmap='viridis')
    plt.title("Original (Rango 100)")
    plt.axis('off')

    for i, k in enumerate(ranks):
        # Reconstrucción: U[:, :k] @ Sigma[:k, :k] @ Vt[:k, :]
        # En numpy, 's' es un vector, lo convertimos a diagonal
        A_approx = U[:, :k] @ np.diag(s[:k]) @ Vt[:k, :]
        
        plt.subplot(2, 3, i + 2)
        plt.imshow(A_approx, cmap='viridis')
        plt.title(f"Reconstrucción con k={k}")
        plt.axis('off')

    plt.tight_layout()
    plt.show()

    # Mostrar la importancia de los valores singulares
    plt.figure(figsize=(6, 4))
    plt.plot(s, 'ro-', markersize=2)
    plt.title("Magnitud de los Valores Singulares ($\sigma$)")
    plt.xlabel("Índice")
    plt.ylabel("Valor")
    plt.grid(True)
    plt.show()

if __name__ == "__main__":
    svd_compression_demo()

La jerarquía de la información: Verás que con solo k=5 o k=10 valores singulares, ya puedes reconocer la forma general del patrón. Esto es porque los primeros valores de $\sigma$ capturan la mayor parte de la varianza (energía) del sistema.
Reducción de ruido: En Machine Learning, a menudo los valores singulares más pequeños representan "ruido". Al descartarlos (Truncated SVD), no solo comprimes, sino que limpias tus datos.

recuerda siempre la conexión sagrada entre SVD y los Eigenvalores:

Los Valores Singulares ($\sigma_i$) son las raíces cuadradas de los eigenvalores de $A^T A$.
Los Vectores Singulares Derechos ($V$) son los eigenvectores de $A^T A$.
Los Vectores Singulares Izquierdos ($U$) son los eigenvectores de $AA^T$.

Much ode esto ha sido expliicado por el profesor durante esgte curso, por tanto si Gemini y @Daniel dicen l omismo es por la plena real.

Bryan Castano

student••

Hola Chicos X2. Aqui estoy de nuevo con este, el codigo mejorado del reto. "Gemini me ayudo un poco, lo acepeto, Yo tambien se programar bien solo fue una AI code help" \n este ejemplo es mas bonito.

import numpy as np
import matplotlib.pyplot as plt
from skimage import data
from skimage.transform import resize
from skimage.color import rgb2gray

def run_svd_analysis():
    # 1. Preprocesamiento: Cargar imagen y convertir a escala de grises
    # Usamos data.cat() como en tu ejemplo
    original_img = rgb2gray(data.cat())
    image = resize(original_img, (300, 200))
    
    # 2. Descomposición SVD
    # A = U * Sigma * V^T
    U, S, VT = np.linalg.svd(image, full_matrices=False)
    
    # 3. Configuración de parámetros (Primeros 7 términos de Fibonacci)
    k_values = [1, 2, 3, 5, 8, 13, 21]
    
    # --- VISUALIZACIÓN DE IMÁGENES RECONSTRUIDAS ---
    # Creamos un layout de 2x4 (8 espacios: 1 para original + 7 para k_values)
    fig, axes = plt.subplots(2, 4, figsize=(16, 10))
    axes = axes.flatten() # Aplanamos para iterar fácilmente
    
    # Espacio 0: Imagen Original
    axes[0].imshow(image, cmap='gray')
    axes[0].set_title("Original (Full Rank)", fontsize=10, fontweight='bold')
    axes[0].axis('off')
    
    # Espacios 1-7: Reconstrucciones
    for i, k in enumerate(k_values):
        # Reconstrucción de bajo rango (Rank-k Approximation)
        # Rebuilt = U_k * Sigma_k * V^T_k
        rebuilt_img = U[:, :k] @ np.diag(S[:k]) @ VT[:k, :]
        
        idx = i + 1
        axes[idx].imshow(rebuilt_img, cmap='gray')
        axes[idx].set_title(f"Rebuilt k={k} (Fibonacci)", fontsize=10)
        axes[idx].axis('off')

    plt.suptitle("Image Compression via Singular Value Decomposition (SVD)", fontsize=16)
    plt.tight_layout()
    
    # --- VISUALIZACIÓN DE VALORES SINGULARES (SIGMA) ---
    plt.figure(figsize=(10, 5))
    plt.plot(S, color='crimson', lw=2, label='Singular Values ($\sigma_i$)')
    
    # Resaltar los valores de k usados (Fibonacci)
    plt.scatter(k_values, S[k_values], color='blue', zorder=5, label='k-points used')
    
    plt.title("Decaimiento de la Energía (Valores Singulares)", fontsize=14)
    plt.xlabel("Índice del Valor Singular ($i$)")
    plt.ylabel("Magnitud ($\sigma_i$)")
    plt.yscale('log') # Escala logarítmica para ver mejor el decaimiento
    plt.grid(True, which="both", ls="-", alpha=0.5)
    plt.legend()
    
    plt.show()

if __name__ == "__main__":
    run_svd_analysis()

Este es el primer output :

Yo he querido que los vlaores k sigan la secuencia de Fibonacci proque es fantastica en progrmaacion y me gusta ver en que punto el Gato se ve mejor como el gato de lai magne original para un valor k?.

Observa la gráfica pseudo-Log de los valores singulares. El punto donde la curva se vuelve casi plana (el "codo") te indica cuánta información es realmente necesaria para representar la imagen. Con $k=21$, verás que ya se distingue perfectamente al gato, ¡a pesar de que la matriz original tiene rango 200! Estás comprimiendo la información casi un 90%.

Aproximación de Bajo Rango: Matemáticamente, lo que estás haciendo es el Teorema de Eckart-Young-Mirsky, que dice que la mejor aproximación de rango $k$ de una matriz (en norma de Frobenius) es precisamente la que obtienes truncando la SVD.

El valor optimo de k para convervar la mayor informacion psible de la imagen original esta entre [13 , 21 ] , tal vez sea 16 -> 2**4 l ocual hace sentido.

\nMuchas Gracias al Profesor @Daniel pro tan buen curso, los tres han sido geniales, fue un todo un viaje de nuevo que he pasado , Yo ya habia visto Algebra Lienal I,II en la Universidad con Matlab, ahora l ohe vuelto a entender mejro y con ayuda de Python es mas bonito.

print("Nunca pares de Aprender")

Daniel Erazo

teacher•

Qué interesante mejora al código, gran trabajo!

Emilio José Chaparro Barrera

student•

En este caso cada componente es un fragmento de una única imagen, en PCA aplicado a eigen faces cada componente una eigenface que pueden construir múltiples caras. Pero SVD también es aplicable a eigenfaces, solo que ya no con img ej. 64x64 px sino ej. 1920x1080 px. En SVD la matriz U es los eigenvectores de la matrix de covarianza A@A.T y serán las eigenfaces.

Emilio José Chaparro Barrera

student•

Ademas al final nombrando el Denoising seria posible pasar una img pixelada vieja y dejarla sin ruido, teniendo como resultado algo mas nitido, eliminando componentes.

Gabriel Obregón

student•

🧮🖼️ Compresión de Imágenes con SVD en Python

🎯✨ IDEA PRINCIPAL

La descomposición en valores singulares (SVD) es una técnica para:

✔️ Comprimir imágenes

✔️ Reducir ruido

✔️ Mantener la estructura visual esencial

🔑 Se conserva solo la información más importante de la imagen.

Resultado final: 📉 Menos datos | ⚡ Más velocidad | 👁️ Buena calidad visual

🧠🔍 ¿QUÉ ES SVD?

Una imagen en escala de grises se representa como una matriz numérica.

Al aplicar SVD, la imagen se separa en tres componentes:

▶️ U → estructura principal

▶️ Σ (S) → valores singulares (importancia)

▶️ Vᵀ (VT) → estructura complementaria

📐 Relación fundamental:

imagen ≈ U × Σ × V transpuesta

🔝 Valores grandes → formas y contrastes principales 🔻 Valores pequeños → ruido y detalles finos

🖼️⚙️ TRATAMIENTO DE LA IMAGEN

✔️ Conversión a escala de grises

✔️ Uso de una sola matriz (no RGB)

✔️ Redimensionado para eficiencia

📏 Ejemplo usado:

· Tamaño: 300 × 200 píxeles

· Total original: 60 000 valores

📐📊 DIMENSIONES TRAS SVD

Para una imagen de 300 × 200:

🧩 U → 300 × 300

🧩 S → 200 valores singulares

🧩 Vᵀ → 200 × 200

📌 Estas dimensiones permiten reconstruir la imagen usando solo una parte de la información.

🔄🧱 PROCESO DE COMPRESIÓN

1️⃣ Convertir a escala de grises

2️⃣ Redimensionar la imagen

3️⃣ Aplicar SVD

4️⃣ Elegir k valores singulares

5️⃣ Reconstruir la imagen

6️⃣ Evaluar calidad vs. compresión

🧠 Menos k → más compresión 👁️ Más k → más calidad

🧩🔢 RECONSTRUCCIÓN CON k

Para reconstruir:

🔹 Primeras k columnas de U

🔹 Primeros k valores de S

🔹 Primeras k filas de Vᵀ

📦 Solo se conserva la información más relevante.

import numpy as np
import matplotlib.pyplot as plt

def svd_compression_demo():
    # 1. Crear una matriz de 100x100 con un patrón (nuestra "imagen")
    # Usamos un producto exterior para crear una matriz de bajo rango
    x = np.linspace(-5, 5, 100)
    y = np.linspace(-5, 5, 100)
    X, Y = np.meshgrid(x, y)
    A = np.sin(X) + np.cos(Y) # Un patrón complejo

    # 2. Aplicar SVD
    # U: Vectores izquierdos, s: Valores singulares, Vt: Vectores derechos
    U, s, Vt = np.linalg.svd(A)

    # 3. Reconstrucción con diferentes rangos (k)
    # k es el número de valores singulares que decidimos mantener
    ranks = [2, 5, 10, 50]
    
    plt.figure(figsize=(12, 8))
    
    # Imagen Original
    plt.subplot(2, 3, 1)
    plt.imshow(A, cmap='viridis')
    plt.title("Original (Rango 100)")
    plt.axis('off')

    for i, k in enumerate(ranks):
        # Reconstrucción: U[:, :k] @ Sigma[:k, :k] @ Vt[:k, :]
        # En numpy, 's' es un vector, lo convertimos a diagonal
        A_approx = U[:, :k] @ np.diag(s[:k]) @ Vt[:k, :]
        
        plt.subplot(2, 3, i + 2)
        plt.imshow(A_approx, cmap='viridis')
        plt.title(f"Reconstrucción con k={k}")
        plt.axis('off')

    plt.tight_layout()
    plt.show()

    # Mostrar la importancia de los valores singulares
    plt.figure(figsize=(6, 4))
    plt.plot(s, 'ro-', markersize=2)
    plt.title("Magnitud de los Valores Singulares ($\sigma$)")
    plt.xlabel("Índice")
    plt.ylabel("Valor")
    plt.grid(True)
    plt.show()

if __name__ == "__main__":
    svd_compression_demo()

import numpy as np
import matplotlib.pyplot as plt
from skimage import data
from skimage.transform import resize
from skimage.color import rgb2gray

def run_svd_analysis():
    # 1. Preprocesamiento: Cargar imagen y convertir a escala de grises
    # Usamos data.cat() como en tu ejemplo
    original_img = rgb2gray(data.cat())
    image = resize(original_img, (300, 200))
    
    # 2. Descomposición SVD
    # A = U * Sigma * V^T
    U, S, VT = np.linalg.svd(image, full_matrices=False)
    
    # 3. Configuración de parámetros (Primeros 7 términos de Fibonacci)
    k_values = [1, 2, 3, 5, 8, 13, 21]
    
    # --- VISUALIZACIÓN DE IMÁGENES RECONSTRUIDAS ---
    # Creamos un layout de 2x4 (8 espacios: 1 para original + 7 para k_values)
    fig, axes = plt.subplots(2, 4, figsize=(16, 10))
    axes = axes.flatten() # Aplanamos para iterar fácilmente
    
    # Espacio 0: Imagen Original
    axes[0].imshow(image, cmap='gray')
    axes[0].set_title("Original (Full Rank)", fontsize=10, fontweight='bold')
    axes[0].axis('off')
    
    # Espacios 1-7: Reconstrucciones
    for i, k in enumerate(k_values):
        # Reconstrucción de bajo rango (Rank-k Approximation)
        # Rebuilt = U_k * Sigma_k * V^T_k
        rebuilt_img = U[:, :k] @ np.diag(S[:k]) @ VT[:k, :]
        
        idx = i + 1
        axes[idx].imshow(rebuilt_img, cmap='gray')
        axes[idx].set_title(f"Rebuilt k={k} (Fibonacci)", fontsize=10)
        axes[idx].axis('off')

    plt.suptitle("Image Compression via Singular Value Decomposition (SVD)", fontsize=16)
    plt.tight_layout()
    
    # --- VISUALIZACIÓN DE VALORES SINGULARES (SIGMA) ---
    plt.figure(figsize=(10, 5))
    plt.plot(S, color='crimson', lw=2, label='Singular Values ($\sigma_i$)')
    
    # Resaltar los valores de k usados (Fibonacci)
    plt.scatter(k_values, S[k_values], color='blue', zorder=5, label='k-points used')
    
    plt.title("Decaimiento de la Energía (Valores Singulares)", fontsize=14)
    plt.xlabel("Índice del Valor Singular ($i$)")
    plt.ylabel("Magnitud ($\sigma_i$)")
    plt.yscale('log') # Escala logarítmica para ver mejor el decaimiento
    plt.grid(True, which="both", ls="-", alpha=0.5)
    plt.legend()
    
    plt.show()

if __name__ == "__main__":
    run_svd_analysis()

Compresión de imágenes con SVD en Python

Preparación y Transformaciones Lineales

Cómo descomponer matrices con PCA y SVD

Cómo las matrices transforman vectores en Python

Eigen-Análisis

Cómo verificar la ecuación A·v = λ·v con NumPy

Matriz de covarianza y eigenvectores en Python

Reducción de Dimensionalidad con PCA

Por qué más dimensiones empeoran tus modelos ML

PCA desde cero con NumPy paso a paso

Eigenfaces: cómo PCA comprime rostros

Cómo interpretar componentes principales en PCA

Descomposición en Valores Singulares (SVD)

Cómo SVD supera las limitaciones de eigenvectores

Cómo SVD transforma círculos en elipses

Aplicación de SVD en NumPy