¿Cómo descompongo una matriz no cuadrada (SVD)?

Al final de la clase el profesor hace mencion de una operacion entre matrices que hace que volvamos a tener la matriz original. En este caso multiplica U D V en ese orden.
Sin embargo no lo hace en codigo y a simple vista puede salirnos un error de compatibilidad de dimensiones, pues U es 2x2, D (como lo hizo el profesor) es 2x2 y V es 3x3. Y no se puede multiplicar una matriz 2x2 con una 3x3. Lo que hice y dio resultado fue aumentar una columna extra de 0’s al vector D para que ahora sea de 2x3 y realice la multiplicacion y el metodo SVD queda comprobado aqui les dejo el codigo.

import numpy as np

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

U, D, V = np.linalg.svd(A)

magicMatrix = np.array([[D[0],0,0],[0,D[1],0]])
A_calc = U.dot(magicMatrix).dot(V)

magicMatrix tendra ese cambio que mencione arriba y A_calc puede comprobarse que es igual a la matriz A original

Hice esta pequeña funcion para comprobar con matrices aleatorias la descomposicion por valores singulares. En la función verifico que las dimensiones de las matrices concuerden para realizar la operacion, y si no es asi, les agrego las columnas extras para que coincidan. La dejo aqui por si quieren practicar tambien

Matrices aleatorias:

B = np.random.randint(1, 5, size=(3,4))

Descomposicion:

def SVD(A):
    U,D,V = np.linalg.svd(A)
    D = np.diag(D)
    
    if D.shape[1] != V.shape[0]:
        n_columns = np.abs(D.shape[0]-V.shape[0])
        extend = np.zeros(( D.shape[0] , n_colums ))
        D = np.append(D, extend, axis=1)
    
    return U,D,V

Como pueden ver funciona bien 😄

![](

Descomposición de una matriz en valores singulares
La descomposición por autovectores sólo es aplicable a matrices cuadradas. El presente método permite descomponer cualquier matriz en tres matrices:

• U → vectores izquierdos singulares
• D → matriz diagonal de valores singulares
• V → vectores derechos singulares

Estos valores se obtienen en python mediante el método:

U,D,V = np.linalg.svd(matriz)

Nota:
Podemos ve a una matriz rectangular como una subtransformación del espacio, es decir podemos condensar información de tres a dos dimensiones.

Para calcular la matriz de vuelta esta es una solución genérica usando las propiedades de las matrices

m = np.array([[1,2 ,3], [3 ,4, 5]])
U, D, V = np.linalg.svd(m)
DMatrix = np.diag(D).dot(np.eye(len(U), len(V)))
U.dot(DMatrix).dot(V)

Para entender chido la matemática detrás comparto estos recursos que me ayudaron a mí.

Clase del MIT

Notas/resume de la clase del MIT

Interpretación 1

Interpretación 2

Encontré este documento y me ayudo a profundizar un poco más en el tema

Valores singulares. ¿Què son?.¿Para què sirven?

• **Descomposición en valores singulares: **Tendremos una matriz con los vectores derechos singulares, Una matriz con los vectores izquierdos singulares, éstas dos son matrices ortogonales.(todos los vectores son ortonormales.), Una matriz diagonal con los valores singulares.

U, D, V = np.linalg.svd(A, full_matrices=True)
print(U.shape)
print(D.shape)
print(V.shape)
(2, 2)
(2,)
(3, 3)
S = np.zeros((2, 3))
S[:2,:2] = np.diag(D)
print(S)
[[7.97638869 0.         0.        ]
 [0.         0.61418515 0.        ]]
A_calc = U.dot(S).dot(V)
print(A_calc)
[[1. 2. 3.]
 [3. 4. 5.]]

Hola, el siguiente código completa la matríz D para que el productos sea consistente:

import numpy as np

A = np.array( [ [ 1 , 2 , 3 ] ,
               [ 3 , 4 , 5 ] ] )

U , D , V = np.linalg.svd( A )

m =  U.shape[ 1 ]
n = V.shape[ 0 ]
k = min( m , n )

matriz_vacia = np.zeros( ( m , n ) )

for i in range( k ):
    matriz_vacia[ i , i ] = D[ i ] 

Pueden comprobarlo haciendo el producto:

U @ matriz_vacia @ V

Por alguna razón el profesor no realiza la demostración. Para los que no la pudieron hacer:

1. Convertir D en una matriz diagonal

D = np.diag(D)

1. Luego modificar su dimensión de 2x2 a 2x3 agregando una columna para que el producto esté definido en el siguiente paso

D = np.append(D,[[0],[0]],axis=1)

1. Simplemente realizar la multiplicación

calc_A = U.dot(D).dot(V)

Recomiendo fuertemente seguir Esta serie de videos para comprender la descomposición en valores singulares.

Dejo una imagen de mi notebook de esta clase:

En el minuto 2 el profesor habla de trabajar con matrices no cuadradas, si intentas hacer el producto interno de las matrices obtendrás un error (inténtalo y lee detenidamente el error).

Bien para solucionar esto es necesario que todas las matrices tengan o la misma dimensión, o al menos dimensiones compatibles para realizar el producto interno, esto lo logramos agregando artificialmente 1 columna auxiliar con ceros a U y a V. (En este punto desconozco el fundamentado matemático que nos permita o nos de la pauta para ello, pero me recuerda a la matriz aumentada en eliminacion de gauss, si alguien tiene mas info, se agradece).

Aqui varias formas de agregar esa columna (tambien dejare como agregar un renglon como contenido extra)

#Forma 1 Agregar columna hstack y fila vstack 

np.hstack((U,np.zeros((2,1))))

array([[-0.46410668, -0.88577931,  0.        ],
       [-0.88577931,  0.46410668,  0.        ]])

np.vstack((U,np.zeros((1,2))))

array([[-0.46410668, -0.88577931],
       [-0.88577931,  0.46410668],
       [ 0.        ,  0.        ]])

#Forma 2 utilizando append
>>> a = np.array([[1,2,3],[2,3,4]])
>>> a
array([[1, 2, 3],
       [2, 3, 4]])

>>> z = np.zeros((2,1), dtype=int64)
>>> z
array([[0],
       [0]])

>>> np.append(a, z, axis=1)
array([[1, 2, 3, 0],
       [2, 3, 4, 0]])

Los creditos de los metodos mas otras formas adicionales en este link
https://www.it-swarm.dev/es/python/como-agregar-una-columna-extra-una-matriz-numpy/941160214/

**La descomposición en valores singulares (SVD) también se puede aplicar a matrices no cuadradas. La descomposición SVD de una matriz rectangular M de tamaño m x n, donde m es el número de filas y n es el número de columnas, se puede realizar de la siguiente manera **

import numpy as np

# Definir una matriz no cuadrada
M = np.array([[1, 2, 3],
              [4, 5, 6]])

# Calcular la descomposición SVD
U, S, V = np.linalg.svd(M)

# Imprimir las matrices U, S y V
print("Matriz U:")
print(U)
print("Matriz S:")
print(np.diag(S))
print("Matriz V:")
print(V)

• La función np.linalg.svd() devuelve tres valores: U, S y V. La matriz U contiene los autovectores izquierdos, la matriz S es una matriz diagonal con los valores singulares en el orden descendente y la matriz V contiene los autovectores derechos.

• Es importante tener en cuenta que en el caso de una matriz no cuadrada, la matriz S no será una matriz cuadrada, sino que tendrá dimensiones m x n, donde m es el número de filas de M y n es el número de columnas de M.

Ojo que en la operación de U, D, V
Tanto U y V son matrices cuadradas que respetan la forma de la matriz original. Ej si la matriz original A tiene forma (2,3), U es cuadrada de forma (2,2) y V es (3,3). Entonces D debe ser (2,3) para conseguir la transformación de dimensiones.

Para lograrlo en numpy, el relleno de 0s no es necesario realizar por concatenación, hay un método directo en numpy.

Pongámoslo en términos generales. Siendo A la matriz no cuadrada de forma (x,y). Su descomposición viene dada por:

import numpy as np
U, D, V = np.linalg.svd(A)
D = np.pad(np.diag(D),((0,A.shape[0]-len(D)),(0,A.shape[1]-len(D))))

A partir de ahí si multiplicas U @ D @ V obtienes la matrix original no cuadrada A.
La forma en la que funciona np.pad es:
Primero: Se coloca el array
Segundo: Se coloca una tupla de tuplas ((a,b),(c,d)). Donde “a” y “b” son la cantidad de filas cero que se agregan antes y después (Como antes no debo agregar, en el después agrego la resta entre la forma de A y D). “c” y “d” hace lo mismo pero a nivel de columnas

Una matriz ortogonal es aquella en la que todas sus columnas son vectores ortogonales unitarios. Esto significa que cada columna tiene magnitud igual a 1 y que cualquier par de columnas son perpendiculares entre sí.

Si gustan entender más a cerca de como se calculan los valores singulares, chequen este video de un ejercicio del MIT. Resuelve muchas de las dudas:

si quieren obtener otra vez la matriz, se tiene que generar la diagonal otra vez que tenga el mismo tamaño que la matrix original

U.dot(np.diag(D,k=-1)[1:]).dot(V)

out:

array([[1., 2., 3.],
       [3., 4., 5.]])

En qué tipo de escenarios de Machine learning podré aplicar los conocimientos de esta clase?

El núcleo de A es la recta con ecuaciones x=t, y=-2t, z=t para todo t real. Esto quiere decir que todos los puntos en la recta se convierten a 0 después de aplicar la transformación. Esta es la “información en R3 que es condensada” de la que habla el profe.

Una forma de calcularlo es resolviendo la ecuación Ax=0. Sin embargo es más interesante descubrirlo directamente del procedimiento de SVD para entenderlo mejor.

Si hacemos manualmente la descomposición, cuando encontremos a V usando A^T A = V D^2 V^T, veremos que el tercer autovalor es 0, y el tercer autovector es justamente x=t, y=-2t, z=t. La interpretación de esto es justamente que los puntos en la recta se van a condensar porque van a ser escalados por un factor de 0, y por lo tanto todos se reducen a 0.

No estoy seguro de si tendríamos la misma coincidencia de que encontremos al núcleo de A entre los autovectores de A^T A ó A A^T para cualquier matriz. Pero bueno, para este caso se me hizo muy interesante y se los comparto.

para agregar la columna de ceros yo utilice:
D=np.append(D,np.zeros((D.shape[0],1)),axis=1)