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.

fullscreen
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.

fullscreen
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.

fullscreen
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.

fullscreen
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.

fullscreen
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.