Aplicación de SVD en NumPy

Aplicar SVD con NumPy te permite descomponer cualquier matriz en tres piezas clave para entenderla, reconstruirla y, además, filtrar ruido en sistemas de recomendación. Aquí verás el flujo completo: crear A, obtener U, S y VT, formar Sigma correctamente y usar k para quedarte con los patrones que importan.

¿Cómo aplicar SVD en NumPy para descomponer y reconstruir matrices?

Empezamos en Google Colab importando NumPy y creando una matriz rectangular A de 3x2. Con np.linalg.svd obtenemos las tres transformaciones: U, S (valores singulares) y VT. En NumPy, S regresa como vector, así que formamos una Sigma rectangular para reconstruir A.

¿Qué hace np.linalg.svd y qué devuelve?

• Descompone A en U, S y VT.
• S contiene los valores singulares de mayor a menor.
• VT contiene vectores relacionados con A transpuesta por A; sus columnas corresponden a los eigenvectores de AᵗA.

import numpy as np

A = np.array([[1, 2],
              [3, 4],
              [5, 6]])
print('shape:', A.shape)

U, S, VT = np.linalg.svd(A)
print('matriz U:\n', U)
print('Sigma (vector S):\n', S)
print('V transpuesta (VT):\n', VT)

¿Cómo formar Sigma y reconstruir A?

• Creamos Sigma con ceros del mismo shape que A.
• Incrustamos np.diag(S) en la esquina superior izquierda de Sigma.
• Reconstruimos con el orden: U @ Sigma @ VT.
• Interpretación: rotación, escalado y cambio de dimensión, luego rotación de salida.

Sigma = np.zeros(A.shape)
Sigma[:len(S), :len(S)] = np.diag(S)

A_reconstruida = U @ Sigma @ VT
print('A original:\n', A)
print('A reconstruida:\n', A_reconstruida)

¿Cómo filtrar ruido con SVD en un sistema de recomendación?

Modelamos 4 usuarios x 3 películas: Dune (ciencia ficción), Shrek (comedia) y Los Cazafantasmas (híbrida). Definimos dos patrones de gustos: uno de ciencia ficción y otro de comedia. Construimos una matriz señal de rango 2 combinando estos patrones y luego añadimos ruido para simular inconsistencias reales. Con SVD de la matriz ruidosa, los valores singulares revelan cuántos patrones dominan.

¿Cómo se construye la señal y el ruido?

• Patrón sci-fi alto en Dune, bajo en Shrek, medio-alto en la híbrida.
• Patrón comedia bajo en Dune, alto en Shrek, medio en la híbrida.
• Señal: usuarios puros y combinaciones lineales de ambos patrones.
• Ruido: matriz aleatoria con np.random.randn escalada por 0.3.

patron_sci_fi = np.array([5, 1, 4])
patron_comedia = np.array([1, 5, 3])

A_signal = np.array([
    patron_sci_fi,
    patron_comedia,
    0.5*patron_sci_fi + 0.5*patron_comedia,
    0.8*patron_sci_fi + 0.2*patron_comedia
])
print('shape:', A_signal.shape)  # 4 x 3

ruido = 0.3 * np.random.randn(4, 3)
A_ruidosa = A_signal + ruido

¿Cómo identificar k con valores singulares?

• Aplicamos SVD a la matriz ruidosa.
• Observamos S: dos valores grandes y un tercero muy pequeño.
• Decisión: k = 2 para conservar los dos patrones fuertes y tratar el tercero como ruido.

U, S, VT = np.linalg.svd(A_ruidosa)
print('valores singulares:', np.round(S, 2))

¿Cómo reconstruir con k=2 y qué significa?

• Tomamos U_k, S_k y VT_k con las primeras k componentes.
• Reconstruimos A_filtrada: aproxima bien la señal original y elimina ruido.
• Lectura práctica: te quedas con lo que más importa para recomendar mejor.

k = 2
U_k = U[:, :k]
S_k = np.diag(S[:k])
VT_k = VT[:k, :]

A_filtrada = U_k @ S_k @ VT_k
print('A_filtrada:\n', np.round(A_filtrada, 2))
print('A_signal:\n', A_signal)

¿Qué aprendizajes y habilidades clave obtienes con SVD?

SVD no solo descompone: también diagnostica patrones, filtra ruido y permite compresión eficiente. En matrices grandes, como las de plataformas con millones de usuarios y películas, se observan los valores singulares y suelen conservarse solo los principales (por ejemplo, 50 o 100) para capturar patrones de gusto latentes.

• SVD: descomposición en U, Sigma y VT para entender transformaciones básicas.
• Valores singulares: orden de importancia de patrones en los datos.
• Sigma rectangular: construcción desde el vector S con np.diag y slicing.
• Reconstrucción: U @ Sigma @ VT y lectura geométrica de las transformaciones.
• Selección de k: conservar lo esencial y tratar lo pequeño como ruido.
• Filtrado de ruido: mejora la señal de calificaciones y la estabilidad de recomendaciones.
• Compresión: almacenar pocos patrones en lugar de matrices gigantes.
• Interpretación de U y VT: U relaciona usuarios con patrones; VT relaciona películas con patrones; recomendación por similitud de perfiles.
• Herramientas NumPy: np.array, np.linalg.svd, np.diag, np.zeros, np.random.randn, np.round.

Ponlo en práctica: vuelve al proyecto y reconstruye con k = 1. ¿Qué tan bien captura las preferencias originales de los usuarios? Comparte tu matriz y tu análisis en los comentarios.