Python PyTorch – método linalg.norm()

El método linalg.norm() de PyTorch calcula una norma vectorial o matricial. La norma es siempre un número real no negativo que es una medida de la magnitud de la array. Acepta un vector o array o lote de arrays como entrada. Admite entradas de tipo flotante, doble, cfloat y cdouble. Usaremos la siguiente sintaxis para calcular la norma vectorial o matricial.

Sintaxis: torch.linalg.norm(A, ord=Ninguno, dim=Ninguno, keepdim=False, *, out=Ninguno, dtype=Ninguno)

Parámetros:

• A:  el tensor de entrada con la forma (*, n) o (*, m, n) donde * es cero o más dimensiones del lote.
• ord: orden de norma.
• dim: son las dimensiones sobre las que calcular la norma. Es opcional y puede ser un valor entero o una tupla de valores enteros.
• keepdim:  valor booleano opcional. Si es True, las dimensiones reducidas se conservan en el resultado como dimensiones con tamaño uno.
• salida: salida opcional.
• dtype : un argumento de palabra clave opcional. Si se especifica, la entrada se convierte en dtype y luego se calcula la norma, y ​​el tipo de tensor devuelto será dtype .

Retorno: devuelve el tensor en valor real, incluso cuando A es complejo.

Este método calcula una norma vectorial si dim es un int y una norma matricial si dim es una tupla de 2. Si tanto dim como ord son None , el tensor de entrada A se aplanará al vector 1D y se calculará la norma 2. Si ord != Ninguno y dim= Ninguno , A debe ser 1D o 2D.

Ejemplo 1:

En el siguiente ejemplo, encontramos la norma vectorial usando el método torch.linalg.norm() . Definimos un tensor 1D (vector) y calculamos la norma con los parámetros predeterminados del método. También remodelamos el tensor 1D a 2D y calculamos la norma. Aquí, la norma de 1D Tensor y 2D Tensor es la misma. Los elementos de ambos tensores son los mismos y los parámetros predeterminados son ord = Ninguno, dim = Ninguno. Entonces, el tensor 2D se aplana a 1D y se calcula la norma vectorial. Observe que la norma es el número de valor real no negativo.

# Python program to compute vector norm
# importing libraries
import torch
import torch.linalg as la
  
# define input a 1D tensor
a = torch.tensor([-3., -4., 1., 0., 3., 2., -1., -7.])
print("1D Tensor:\n", a)
  
# computing the norm
norm = la.norm(a)
  
# print the computed norm
print("Norm:", norm)
  
# reshape the tensor to 2D tensor
a = a.reshape(2, 4)
print("2D Tensor:\n", a)
  
# again compute the norm
norm = la.norm(a)
  
# print the norm
print("Norm:", norm)

Producción:

1D Tensor:
 tensor([-3., -4.,  1.,  0.,  3.,  2., -1., -7.])
Norm: tensor(9.4340)
2D Tensor:
 tensor([[-3., -4.,  1.,  0.],
        [ 3.,  2., -1., -7.]])
Norm: tensor(9.4340)

Ejemplo 2:

En el siguiente ejemplo, encontramos la norma de array utilizando el método torch.linalg.norm() . Definimos un tensor 2D (array) y calculamos la norma de la array con diferentes valores de ord . Y el tensor de entrada es un tensor 2D (array). Las normas de la array calculada son diferentes para diferentes valores ord. Tenga en cuenta que ord = 0 no es compatible con la norma matricial y ord =”fro”, ord = “nuc” no son compatibles con la norma vectorial (tensor 1D). Además, tenga en cuenta que la norma es un número de valor real no negativo.

# Python program to compute norm
# importing libraries
import torch
import torch.linalg as la
  
# define input a 2D tensor (matrix)
a = torch.tensor([[1., 2., -3.],
                  [-4., 5., 6.],
                  [9., -7., 8.]])
print("Tensor:\n", a)
  
# compute and print the computed norm
print("\nNorm with different ord:\n")
print("Norm with ord= None:",
      la.norm(a, ord=None))
print("Norm ord= 'fro':",
      la.norm(a, ord='fro'))
print("Norm with ord= float('inf'):",
      la.norm(a, ord=float('inf')))
print("Norm with ord= -float('inf'):",
      la.norm(a, ord=-float('inf')))
print("Norm with ord= 'nuc'):",
      la.norm(a, ord='nuc'))
  
# print("Norm with ord= 0:", la.norm(a, ord= 0))
# ord=0 not supported for matrix norm
print("Norm with ord= 1:",
      la.norm(a, ord=1))
print("Norm with ord= -1:",
      la.norm(a, ord=-1))
print("Norm with ord= 2:",
      la.norm(a, ord=2))
print("Norm with ord= -2:",
      la.norm(a, ord=-1))

Producción:

Tensor:
 tensor([[ 1.,  2., -3.],
        [-4.,  5.,  6.],
        [ 9., -7.,  8.]])

Norm with different ord:

Norm with ord= None: tensor(16.8819)
Norm ord= 'fro': tensor(16.8819)
Norm with ord= float('inf'): tensor(24.)
Norm with ord= -float('inf'): tensor(6.)
Norm with ord= 'nuc'): tensor(25.4331)
Norm with ord= 1: tensor(17.)
Norm with ord= -1: tensor(14.)
Norm with ord= 2: tensor(14.2151)
Norm with ord= -2: tensor(14.)

Ejemplo 3:

En el siguiente ejemplo encontramos las normas utilizando el método torch.linalg.norm() . Definimos un tensor 2D (array) y calculamos la norma con diferentes valores de dim y ord. Y el tensor de entrada es un tensor 2D (array). Las normas de la array calculada son diferentes para diferentes valores de ord y dim. Tenga en cuenta que la norma con dim = 0 se calcula junto con las columnas y la norma con dim=1 se calcula a lo largo de las filas. Además, tenga en cuenta que la norma es un número de valor real no negativo.

# Python program to compute matrix norm
# importing libraries
import torch
import torch.linalg as la
  
# define input a 2D tensor (matrix)
a = torch.tensor([[1., 2., -3.],
                  [-4., 5., 6.]])
print("Tensor:\n", a)
  
# compute and print the computed norm
# with different ord and dim
print("Norm with dim=0:",
      la.norm(a, dim=0))
print("Norm with dim=1:",
      la.norm(a, dim=1))
print("Norm with ord=1, dim=1:",
      la.norm(a, ord=1, dim=1))
print("Norm with ord=-1, dim=1:",
      la.norm(a, ord=-1, dim=1))
print("Norm with ord=1, dim=0:",
      la.norm(a, ord=1, dim=0))
print("Norm with ord=-1, dim=0:",
      la.norm(a, ord=1, dim=1))
print("Norm with dim=(0,1):",
      la.norm(a, dim=(0, 1)))

Producción:

Tensor:
 tensor([[ 1.,  2., -3.],
        [-4.,  5.,  6.]])
Norm with dim=0: tensor([4.1231, 5.3852, 6.7082])
Norm with dim=1: tensor([3.7417, 8.7750])
Norm with ord=1, dim=1: tensor([ 6., 15.])
Norm with ord=-1, dim=1: tensor([0.5455, 1.6216])
Norm with ord=1, dim=0: tensor([5., 7., 9.])
Norm with ord=-1, dim=0: tensor([ 6., 15.])
Norm with dim=(0,1): tensor(9.5394)