Python PyTorch método linalg.svd()

El método PyTorch linalg.svd() calcula la descomposición de valores singulares ( SVD ) de una array. Los tensores 2D son arrays en PyTorch. Este método admite arrays reales y de valores complejos (tipos de d flotante, doble, cfloat y cdouble). Toma como entrada una array o un lote de arrays y devuelve la descomposición como una tupla con nombre (U, S, VT). He enumerado algunas propiedades de U, S y VT a continuación:

• Si la array de entrada A es una array de valores reales, tanto U como VT son ortogonales.
• Si la array de entrada A es una array de valores complejos, U y VT son unitarios.
• S siempre tiene un valor real para la array de entrada A, tanto real como compleja. Los valores singulares (elementos de S) se organizan en orden descendente.

La siguiente es la sintaxis-

Sintaxis: torch.linalg.svd(A, full_arrays=True, *, out=Ninguno)

Parámetros:

• A: la array de entrada (tensor o lote de tensores).
• full_arrays: un valor booleano opcional. Si se calcula la SVD completa verdadera. Si es falso, se calcula la SVD reducida.
• out: la tupla de salida de tres tensores.

Retorno: Devuelve tres tensores como una tupla con nombre (U, S, VT).

Entendamos el método torch.linalg.svd() con la ayuda de algunos ejemplos de programas de Python.

Ejemplo 1:

En este ejemplo, calculamos la descomposición de valores singulares completa de una array de valores reales utilizando torch.linalg.svd(). Aquí, las arrays U y VT son arrays cuadradas y el tamaño de S es min(2,3). Las arrays U y VT son ortogonales. Puede verificar la ortogonalidad de estas arrays usando U@Ut() y VT@VT.t().

# Python program to demonstrate torch.linalg.svd()
# method for a real-valued matrix
# importing torch
import torch
  
# creating a real-valued matrix (2-D tensor)
Mat = torch.tensor([[1.,2.,3.],
                    [3.,-2,-7]])
# printing the matrix               
print("Matrix:\n", Mat)
  
# computing SVD of the matrix Mat
U, S, VT = torch.linalg.svd(Mat)
  
# printing U, S, and Vh
print("U:\n",U)
print("Singular Values (S):\n",S)
print("VT:\n",VT)
print("Shape of U, S and VT:\n", U.shape, S.shape, VT.shape)

Producción:

Matrix:
 tensor([[ 1.,  2.,  3.],
        [ 3., -2., -7.]])
U:
 tensor([[-0.3625, -0.9320],
        [ 0.9320, -0.3625]])
Singular Values (S):
 tensor([8.3999, 2.3329])
VT:
 tensor([[ 0.2897, -0.3082, -0.9061],
        [-0.8657, -0.4882, -0.1107],
        [ 0.4082, -0.8165,  0.4082]])
Shape of U, S and VT:
 torch.Size([2, 2]) torch.Size([2]) torch.Size([3, 3])

Ejemplo 2:

En el siguiente ejemplo, calculamos la descomposición de valores singulares reducidos de una array de valores reales utilizando torch.linalg.svd(). Aquí, se calcula la SVD reducida. Observe que U es cuadrada y VT no lo es, y el tamaño de S es min(3,4). Como la array de entrada es de valor real, las arrays U y VT deben ser ortogonales. Puede verificar la ortogonalidad de estas arrays usando U@Ut() y VT@VT.t(). ¿Qué sucede si la array de entrada Mat en el código anterior es una array de 4 × 3? ¡¡¡Sí!!!. VT es cuadrado y U no lo es.

# Python program to demonstrate torch.linalg.svd()
# method for a real-valued matrix with 
# full_matrices=False
# importing torch
import torch
  
# creating a real-valued matrix (2-D tensor)
Mat = torch.rand(3, 4)
# printing the matrix
print("Matrix:\n", Mat)
  
# computing SVD of the matrix Mat
U, S, VT = torch.linalg.svd(Mat, full_matrices=False)
  
# printing U, S, and Vh
print("U:\n", U)
print("Singular Values (S):\n", S)
print("VT:\n", VT)
print("Shape of U, S and VT:\n", U.shape, S.shape, VT.shape)

Producción:

Tenga en cuenta que como estamos creando una array de entrada utilizando un generador de números aleatorios, puede obtener una array diferente de la salida:

Matrix:
 tensor([[0.5280, 0.3108, 0.1215, 0.8151],
        [0.9640, 0.4199, 0.3913, 0.2239],
        [0.7886, 0.0702, 0.7123, 0.6120]])
U:
 tensor([[-0.4984, -0.7911, -0.3546],
        [-0.5810,  0.6083, -0.5407],
        [-0.6435,  0.0634,  0.7628]])
Singular Values (S):
 tensor([1.8411, 0.5512, 0.4225])
VT:
 tensor([[-0.7227, -0.2412, -0.4053, -0.5052],
        [ 0.3969,  0.0254,  0.3395, -0.8524],
        [-0.2531, -0.6715,  0.6834,  0.1343]])
Shape of U, S and VT:
 torch.Size([3, 3]) torch.Size([3]) torch.Size([3, 4])

Ejemplo 3:

En el siguiente ejemplo, calculamos el SVD completo de una array de valores complejos. Observe que S tiene un valor real y U y VT tienen un valor complejo.

# Python program to demonstrate torch.linalg.svd()
# method for a complex-valued matrix
# importing torch
import torch
  
# creating a complex-valued matrix (2-D tensor)
Mat = torch.randn(3, 2, dtype=torch.cfloat)
# printing the matrix
print("Matrix:\n", Mat)
  
# computing SVD of the matrix Mat
U, S, VT = torch.linalg.svd(Mat)
  
# printing U, S, and Vh
print("U:\n", U)
print("Singular Values (S):\n", S)
print("VT:\n", VT)
print("Shape of U, S and VT:\n", U.shape, S.shape, VT.shape)

Producción:

Tenga en cuenta que, dado que estamos creando una array de entrada con un generador de números aleatorios, es posible que obtenga una array diferente de la siguiente salida

Matrix:
 tensor([[-0.4095-0.8878j,  0.3983+0.5446j],
        [-1.3408+1.1268j,  0.3193+0.9775j],
        [ 0.8876+0.6970j, -0.9217-0.5416j]])
U:
 tensor([[-0.2687-0.3263j, -0.3146+0.2721j,  0.7890+0.1605j],
        [-0.6525+0.3324j, -0.1834-0.6499j,  0.0518+0.0713j],
        [ 0.5008+0.1853j,  0.3777-0.4778j,  0.5800-0.0863j]])
Singular Values (S):
 tensor([2.4929, 1.3183])
VT:
 tensor([[ 0.8916+0.0000j, -0.2928-0.3453j],
        [-0.4527+0.0000j, -0.5767-0.6800j]])
Shape of U, S and VT:
 torch.Size([3, 3]) torch.Size([2]) torch.Size([2, 2])