Funciones de Pytorch: tensor(), fill_diagnol(), append(), index_copy()

Este artículo tiene como objetivo compartir algunas funciones de PyTorch que lo ayudarán mucho en su viaje de aprendizaje profundo y ciencia de datos. Cada función se explicará usando dos ejemplos de escritura y un ejemplo en el que no puede usar esas funciones. Entonces empecemos.

PyTorch es una biblioteca de aprendizaje automático de código abierto, contiene una biblioteca de tensores que permite crear un escalar, un vector, una array o, en resumen, podemos crear una array n-dimensional. Se utiliza en la visión artificial y el procesamiento del lenguaje natural, desarrollado principalmente por el laboratorio de investigación de Facebook. Es un software de código abierto y se publica bajo la licencia modificada BSD (Barkley Software Distribution).

Nuestras cuatro funciones: 

• antorcha.tensor()
• llenar_diagonal_()
• agregar (* tamaño)
• index_copy()

Función 1 – antorcha.tensor()

Esta función nos permite crear tensores de PyTorch. El tensor podría ser cualquier cosa, es decir, podría ser un escalar, podría ser una array unidimensional, podría ser una array n-dimensional.

¿Por qué necesitamos tensores?

Siempre que queramos realizar cualquier cálculo matricial en nuestro modelo de aprendizaje profundo, la primera y más importante tarea es convertir nuestros marcos de datos en una array numérica y luego en tensores o, si estamos trabajando en algún problema de clasificación de imágenes, tenemos que convertir esas imágenes en tensores PyTorch. .

Sintaxis y parámetros:

data:          data that we want to convert into tensor.
dtype:         data type of that data whether it is torch32, torch64 etc.
device:        type of your device whether it is cpu or gpu(cuda).
requires_grad: if it is True, then gradients of that tensor will be saved in
               torch.grad property.

Código: Para crear vectores usando esta función.

# vector of int datatype
t1 = torch.tensor([1, 2, 3, 7, 1])
 
# if one float can convert the whole tensor into flat
t2 = torch.tensor([4, 2, 5, .9]) 
 
# we can convert the tensor data type
t3 = torch.tensor([2, 6, 1, 6, 8.], dtype = torch.int32

En el ejemplo anterior, t1 es el tensor que contiene una array unidimensional simple. En, t2 estamos dentro de la antorcha. Tensor, hemos utilizado un solo elemento flotante, pero debido a ese único, todo nuestro tensor t2 se ha convertido en tipo flotante. En t3 , hemos establecido a la fuerza dtype = torch.int32 para cambiar los tipos de datos de un tensor.

Código: Para crear un tensor usando una array.

t4 = torch.tensor([[3, 6, 8], [2, 6, 8], [0, 7, 4]])

En el ejemplo anterior, hemos creado un tensor t4 que es un tensor 3*3 . De manera similar, si queremos crear un tensor de n dimensiones, podemos crearlo, como un tensor que tenga 4 dimensiones o muchas más.

Ejemplo 3 (el error más común):

En este ejemplo, hablaremos del error comúnmente intentado durante la creación de un tensor. En el ejemplo 2, hemos aprendido que podemos crear una array de n dimensiones.

Código: 

t4 = torch.tensor([[3, 6, 8], [2, 6, 8], [0, 7, 4]])

Aquí hemos creado un tensor de tener dos dimensiones pero cada dimensión no contiene igual no. de elementos, es decir, cada dimensión no tiene la misma longitud. Debido a esto. El compilador arrojará un error, diciendo…

Rastreo de ValueError (última llamada más reciente) <ipython-input-21–28787d136593> en <módulo> 1

# Ejemplo 3?-?rompiendo (para ilustrar cuando se rompe)?-?? 2 antorcha.tensor([[1, 2], [3, 4, 5]])

ValueError: secuencia esperada de longitud 2 en dim 1 (obtuvo 3)

Entonces, lo que aprendimos es que podemos crear una array de n dimensiones, pero todas las dimensiones deben tener la misma longitud; de lo contrario, obtendremos un error.

Función 2 – llenar_diagonal_()

Fill_diagonal() llena la diagonal principal con fill_value pero esa array debe ser una array 2D, para una array ndim> 2, el número de filas debe ser igual al número de columnas y, si no lo es, debemos establecer wrap = True para que la diagonal el valor puede repetirse.

Sintaxis y parámetros: 
fill_diagonal_(fill_value, wrap=False) -> tensor 

fill_value: tensor matrix whose diagonals we want to fill.
wrap:       it takes boolean, it enables us to work with a non-square matrix.

Ejemplo 1:

En este ejemplo, primero crearemos un tensor de tamaño (3, 3) usando torch.zeros (3, 3).

a = torch.zeros(3, 3)

a es un tensor de tamaño (3, 3) que tiene todo su elemento cero, es decir, a es una array cero

ahora lo que queremos es reemplazar todos sus valores diagonales con .4, así que podemos hacerlo con la ayuda de fill_diagonal_().

a.fill_diagonal_(fill_value = 4, wrap = False)
 
print(a)

Si observamos el tensor a, se verá como

tensor([[4., 0., 0.], [0., 4., 0.], [0., 0., 4.]])

Ejemplo 2:

Como aprendimos del ejemplo 1, podemos reemplazar elementos diagonales usando esta función, pero ¿qué pasa si tenemos un tensor en el que no. de filas no es igual a no. de columnas, entonces en este escenario tenemos que configurar el parámetro «envolver» de fill_diagonal_().

Puedes mirar este código,

b = torch.zeros([9, 4])
 
# without putting wrap = True
 
A = b.fill_diagonal_(5, wrap = False)

En el código anterior, primero creamos un tensor cero de tamaño (9, 4), luego llenamos su diagonal con 5 pero no configuramos wrap = True. Ahora veamos el tensor A,

tensor([[5., 0., 0., 0.], [0., 5., 0., 0.], [0., 0., 5., 0.], [0., 0 ., 0., 5.], [0., 0., 0., 0.], [0., 0., 0., 0.], [0., 0., 0., 0.] , [0., 0., 0., 0.], [0., 0., 0., 0.]])

Aquí puede ver que una vez que la diagonal alcanza el final de la longitud de una dimensión particular, el resto de la diagonal no se cambia

Entonces, para resolver este problema, debemos configurar wrap como True. Mira este código,

B = b.fill_diagonal_(6, True)
 
print(B)

Ahora echa un vistazo al tensor B

tensor([[6., 0., 0., 0.], [0., 6., 0., 0.], [0., 0., 6., 0.], [0., 0 ., 0., 6.], [0., 0., 0., 0.], [6., 0., 0., 0.], [0., 6., 0., 0.] , [0., 0., 6., 0.], [0., 0., 0., 6.]])

Observará que incluso la diagonal llega al final de una dimensión particular, nuevamente comienza a cambiar las diagonales de la siguiente dimensión.

Ejemplo 3 (error común):

supongamos que tiene un tensor cero de tamaño (4, 5) y desea cambiar su diagonal con .3 pero si desea cambiar el tipo de datos de ese tensor a int32, entonces probablemente pensará en establecer un dype = torch.int32 en fill_diagonal_() como, 

B = b.llenar_diagonal_(6, Verdadero)

imprimir (B) 

B = b.fill_diagonal_(6, True)
 
print(B)

Pero, aquí tienes que recordar una pequeña cosa que fill_diagonal_() solo toma dos argumentos como parámetro, uno son los datos que quieres poner en diagonal y otro es wrap para trabajar con un tensor no cuadrado,

Entonces, el código anterior arrojará un error como,

Error de tecleado

Rastreo (última llamada más reciente) <ipython-input-26–133c4c6a6759> en <módulo>

1 # ¿Ejemplo 3? -? Rompiendo (pero si intenta establecer su tipo de datos arroja un error)

2 a = antorcha.ceros(4, 5)

– ? 3 a.fill_diagonal_(.3, dtype = torch.float32) TypeError: fill_diagonal_() obtuvo un argumento de palabra clave inesperado ‘dtype’

Función 3: expandir (* tamaño)

• Devuelve una nueva vista del tensor propio con dimensiones singleton expandidas a un tamaño mayor.
• Pasar -1 como el tamaño de una dimensión significa no cambiar el tamaño de esa dimensión.
• Tensor también se puede expandir a una mayor cantidad de dimensiones, y las nuevas se agregarán al frente. Para las nuevas dimensiones, el tamaño no se puede establecer en -1.
• Expandir un tensor no asigna nueva memoria, sino que solo crea una nueva vista en el tensor existente donde una dimensión de tamaño uno se expande a un tamaño mayor al establecer el paso a 0. Cualquier dimensión de tamaño 1 se puede expandir a un valor arbitrario sin asignar nueva memoria.

Sintaxis y parámetro: 

expand(*size)

Ejemplo 1:
si tenemos una array de dimensión única, entonces podemos expandir su dimensión única, usando expand()

a = torch.tensor([[5], [3], [8], [4]])
 
a.size()
 
a.expand(4, 8)

lool en el tensor a,

tensor([[5, 5, 5, 5, 5, 5, 5, 5],

       [3, 3, 3, 3, 3, 3, 3, 3],

       [8, 8, 8, 8, 8, 8, 8, 8],

       [4, 4, 4, 4, 4, 4, 4, 4]])

Inicialmente, a era una array que contenía una dimensión singleton, ahora usando expand() expandimos su dimensión singleton a 8

Ejemplo 2:

b = torch.tensor([[7], [3], [4]])
 
b.size()
 
b.expand(3, -1)

En el ejemplo anterior, colocamos el segundo tamaño como -1, lo que significa que no queremos expandir su dimensión.

Ejemplo 3 (error común):

c = torch.tensor([[4, 6], [9, 6]])
 
c.size()  # this matrix didn't any singleton dimension
 
c.expand(2, 6)

Esto arroja un error porque, de acuerdo con la definición de expand(), tenemos que hacer coincidir un tamaño con la dimensión que no es singleton, pero como tenemos dos dimensiones singleton, no podemos cumplir la condición. Error….

RuntimeError: el tamaño expandido del tensor (6) debe coincidir con el tamaño existente (2) en la dimensión 1 que no es singleton. Tamaños de destino: [2, 6]. Tamaños de tensor: [2, 2]

Función 4 – index_copy_(dim, index, tensor) ? Tensor

Nos permite copiar un tensor en un tensor propio en un índice dado que se define en el tensor de índice que contiene tres argumentos

• oscuro
• tensor de índice para mantener el orden de los índices
• tensor que queremos copiar en nuestro propio tensor

Ejemplo 1:

self_tensor = torch.zeros(6, 3)
 
a
 
t = torch.tensor([[7, 6, 9], [3, 9, 1], [0, 1, 9]], dtype = torch.float)
 
i = torch.tensor([3, 1, 0])
 
self_tensor.index_copy_(0, i, t)

Ahora, si nos fijamos en el tensor de salida…

tensor([[0., 1., 9.],

       [3., 9., 1.],

       [0., 0., 0.],

       [7., 6., 9.],

       [0., 0., 0.],

       [0., 0., 0.]])

En el ejemplo anterior

copiamos t tensor en self_tensor con un orden que se define en i tensor

Ejemplo 2:

a = torch.tensor([[1, 8], [9, 5], [1, 5]])
 
b = torch.tensor([[3, 5], [9, 0], [2, 2]])
 
i = torch.tensor([2, 1, 0])
 
a.index_copy_(0, i, b)

Tensor de salida:

tensor([[2, 2],

       [9, 0],

       [3, 5]])

podemos hacer lo mismo del ejemplo 1 con dos tensores distintos de cero

Ejemplo 3 (error común)

a = torch.tensor([[8, 3], [1, 0]])
 
b = torch.tensor([[3, 9]])
 
i = torch.tensor([1])
 
a.index_copy(1, i, b)

—————————————————————————— RuntimeError 
Traceback (última llamada más reciente) <ipython-input-6-fb983dc7560f> en <módulo> 
3 b = antorcha .tensor([[3, 9]]) 4 i = torch.tensor([1]) —-> 5 a.index_copy(1, i, b) RuntimeError: index_copy_(): El tensor de origen/destino debe tener el mismo segmento formas Forma de corte de destino: 2 en la dimensión 1 y forma de corte de origen: 1 en la dimensión 0. 
 

El ejemplo anterior arroja un error porque hemos intentado dar dim = 1

pero, el elemento dimth del índice debe contener el mismo número de elemento que tantos elementos tiene nuestro tensor b.

Conclusión: siempre que necesitemos copiar un tensor en un tensor propio con un orden específico, podemos usar esta función

Enlaces de referencia –

• Enlace de documentación oficial de PyTorch
• cuaderno para todo el código