Pytorch: operación basada en índices

PyTorch es una biblioteca de Python desarrollada por Facebook para ejecutar y entrenar algoritmos de aprendizaje profundo y aprendizaje automático. Tensor es la estructura de datos fundamental de la máquina o algoritmos de aprendizaje profundo y para tratar con ellos, realizamos varias operaciones, para las cuales la biblioteca PyTorch ofrece muchas funcionalidades.

Las operaciones de tensor que manejan la indexación en alguna fila o columna en particular para copiar, agregar, llenar valores/tensores se dice que son operaciones desarrolladas basadas en índices . Hay dos tipos de operaciones basadas en índices en PyTorch, una es una operación en el lugar y la otra es una operación fuera del lugar. La diferencia básica entre los dos es que la operación en el lugar cambia directamente los valores de los tensores sin hacer ninguna copia de eso, mientras que las operaciones fuera del lugar no lo hacen. Las siguientes son las operaciones: –

1. index_add_
2. index_add
3. index_copy_
4. index_copy
5. index_fill_
6. index_fill
7. index_put_
8. index_put
9. index_select

Ahora discutimos cada una de las funciones con ejemplos apropiados.

1. index_add_:  Agrega los elementos tensoriales dados al tensor propio en el orden dado en la array.

Sintaxis:

 index_add_(dim,index,ensor)---> Tensor

 Parámetros:

• dim: dimensión a lo largo de la cual se agregará el índice. ‘0’ representa columna y ‘1’ representa fila.
• índice: índices del tensor a seleccionar. Puede ser LongTensor o IntTensor .
• tensor: tensor que contiene los valores a sumar.

Ejemplo 1: Tomamos un vector cero ‘x’, un tensor te de tamaño (3,5) y un tensor de índice. Acumulando el vector resultante a lo largo de las filas, obtenemos la salida.

#importing libraries
import torch
  
x=torch.zeros(5,5)
te=torch.tensor([[1,3,5,7,9],[1,3,5,7,9],[1,3,5,7,9]],dtype=torch.float32)
index0=torch.tensor([0,2,4])
#adding tensor te to x along row of the given order
x.index_add_(0,index0,te)

Producción:

tensor([[1., 3., 5., 7., 9.],
        [0., 0., 0., 0., 0.],
        [1., 3., 5., 7., 9.],
        [0., 0., 0., 0., 0.],
        [1., 3., 5., 7., 9.]])

 Ejemplo 2:

#importing libraries
import torch
  
y=torch.ones(5,5)#unitvector
index2=torch.tensor([0,1,1,1,2])
ten=torch.randn(1,5)
#adding values to y along the column with given order
y.index_add_(1,index2,ten)

Producción:

tensor([[0.9460, 0.4762, 1.2219, 1.0000, 1.0000],
        [0.9460, 0.4762, 1.2219, 1.0000, 1.0000],
        [0.9460, 0.4762, 1.2219, 1.0000, 1.0000],
        [0.9460, 0.4762, 1.2219, 1.0000, 1.0000],
        [0.9460, 0.4762, 1.2219, 1.0000, 1.0000]])

2.index_add: Es la versión fuera de lugar de la función anterior. Esto agrega un tensor dado al tensor propio temporalmente. Los parámetros y la sintaxis son los mismos que los anteriores.

Ejemplo 3:

import torch
  
y=torch.ones(5,5)
  
index2=torch.tensor([0,1,1,1,2])
ten=torch.randn(1,5)
print("Indexed Matrix:\n",y.index_add(1,index2,ten))
print ("Printing Indexed Matrix again:\n",y)

Producción:

Indexed Matrix:
 tensor([[-0.2811, -1.0776,  2.2697,  1.0000,  1.0000],
        [-0.2811, -1.0776,  2.2697,  1.0000,  1.0000],
        [-0.2811, -1.0776,  2.2697,  1.0000,  1.0000],
        [-0.2811, -1.0776,  2.2697,  1.0000,  1.0000],
        [-0.2811, -1.0776,  2.2697,  1.0000,  1.0000]])
Printing Indexed Matrix again:
 tensor([[1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.]])

3.index_copy_:  Copia los elementos de un tensor dado al tensor de entrada seleccionando los índices en el orden dado en ‘índice’.

Sintaxis:

index_copy_(dim,index,tensor)---> Tensor

Parámetros:

• dim: dimensión a lo largo de la cual se copia el índice. Es de formato ‘int’.
• índice: índices del tensor a seleccionar. Puede ser IntTensor o LongTensor.
• tensor: tensor que contiene los valores a copiar.

Ejemplo 4:  Aquí los elementos de ‘a’ están siendo reemplazados por el tensor ‘t1’ en un orden dado en el ‘índice3’.

#importing libraries
import torch
  
a=torch.ones(4,4)#unit vector
t1=torch.randn(2,4)
index3=torch.tensor([1,3])
  
#copying elements of t1 ensor to 'a' in given order of index
a.index_copy_(0,index3,t1)

Producción:

tensor([[ 1.0000,  1.0000,  1.0000,  1.0000],
        [-0.1918, -1.2089,  0.3229, -0.1831],
        [ 1.0000,  1.0000,  1.0000,  1.0000],
        [ 0.7521,  0.8424, -0.8698, -0.3908]])

Ejemplo 5: En el siguiente ejemplo, recibiremos un error. Esto se debe a que la dimensión dim ^th del tensor no es igual a la longitud del índice. Por lo tanto, debemos tener en cuenta que la dimensión dim ^th del tensor debe tener el mismo tamaño que la longitud del índice.

#importing libraries
import torch
  
y=torch.ones(5,5)
index1=torch.tensor([0,1,2,3,4])
te=torch.tensor([[1,3,5,7,9],[1,3,5,7,9],[1,3,5,7,9]],dtype=torch.float32)
y.index_copy_(1,index1,te)

Producción:

RuntimeError                              Traceback (most recent call last)
<ipython-input-8-25e4150d5bd7> in <module>
      1 y=torch.ones(5,5)
      2 index1=torch.tensor([0,1,2,3,4])
----> 3 y.index_copy_(1,index1,te)

RuntimeError: index_copy_(): Source/destination tensor must have same slice shapes.
Destination slice shape: 5 at dimension 1 and source slice shape: 3 at dimension 0.

Ejemplo 6: En este, copiaremos el tensor dado al tensor propio teniendo en cuenta que la dimensión dim ^th del tensor debe tener el mismo tamaño que la longitud del índice.

import torch
  
b=torch.ones(4,4)
t2=torch.randn(4,2)
  
index4=torch.tensor([0,1])
b.index_copy_(1,index4,t2)

Producción:

tensor([[-0.3964, -0.3859,  1.0000,  1.0000],
        [ 2.6910, -0.9394,  1.0000,  1.0000],
        [ 0.3591, -0.2262,  1.0000,  1.0000],
        [ 1.2102, -0.8340,  1.0000,  1.0000]])

 4.index_copy: esta es la operación basada en índice fuera de lugar para reemplazar elementos del tensor de entrada con un tensor dado. Sintaxis, los parámetros son los mismos que los anteriores.

5.index_fill_:   el valor ‘Val’ se llena con los elementos de ‘x’ junto con el orden de los índices dados en el vector ‘index’.

Sintaxis:

index_fill_(dim, index, val) → Tensor

Parámetros:

• dim: dimensión a lo largo de la cual rellenar. Es de formato ‘int’.
• índice: llenar en orden los índices dados en este vector índice. Puede ser IntTensor o LongTensor.
• val(float): valor con el que rellenar.

Ejemplo 7: En este ejemplo, declararemos un tensor con elementos aleatorios y luego lo llenaremos con ‘4’ junto con los índices dados.

#importing libraries
import torch
c=torch.randn(4,4)
  
index5=torch.tensor([0,2])
  
#filling 4 within the elements of the tensor 'c' along the indices 0,2
c.index_fill_(0,index5,4)
print(c)

Producción:

 tensor([[ 4.0000,  4.0000,  4.0000,  4.0000],
        [ 0.4762,  0.0056,  0.3258,  1.1345],
        [ 4.0000,  4.0000,  4.0000,  4.0000],
        [-0.1490, -0.6543,  0.9755,  1.8087]])

 Ejemplo 8: De igual forma realizamos una operación de llenado junto con las columnas.

d=torch.randn(5,5)
  
d.index_fill(1,index5,2)
print(d)

Producción:

 tensor([[ 0.5978, -1.2461, -0.8794, -1.0175,  0.8938],
        [-0.6374,  1.0848,  0.1291,  0.6658,  0.3081],
        [-0.9686, -0.8212, -0.5223, -0.3208, -1.7718],
        [-0.1153, -1.2552, -0.4119, -1.1293,  0.2266],
        [ 1.2610,  0.2618, -1.5528,  0.7805,  1.3730]])

 6. index_fill: esta es la operación basada en índice fuera de lugar para llenar los elementos con tensor con ‘val’. Sintaxis, los parámetros son los mismos que los anteriores.

7.index_put_: Esta operación pone el valor de ‘val’ en el tensor propio usando los índices del ‘índice’ dado.

Sintaxis:

index_put_(indices, values, accumulate=False) → Tensor

Parámetros:

• índices: es la tupla de LongTensor que se usa para indexarse ​​a sí mismo.
• valores: Tensor con valores que se deben poner en el objetivo.
• acumular: acumular o no.

Ejemplo 9: Aquí tomamos el vector objetivo y reemplazamos los valores del tensor de valor como se menciona en el 

#importing libraries
import torch
   
target=torch.zeros([4,4])
indices = torch.LongTensor([[0,1],[1,2],[3,1],[1,0]])#indices to which values to be put
value = torch.ones(indices.shape[0])
#tuple of the index tensor is passed along with the value
target.index_put_(tuple(indices.t()), value)

Producción:

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

 Nota: Tenemos que tomar la transposición del tensor de índices o de lo contrario ocurrirá un error.

Ejemplo 10: En este ejemplo, mantenemos la función de acumulación como verdadera, lo que significa que los elementos en valor se agregan al objetivo.

e=torch.ones([4,4])
indices2=torch.LongTensor([[0,1],[0,1],[2,1]])
value2=torch.zeros(indices2.shape[0])
  
e.index_put_(tuple(indices2.t()),value2,accumulate=True)

Output:
tensor([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

8. index_fill: esta es la versión fuera de lugar de index_fill_ . Sintaxis, los parámetros son los mismos que los anteriores.

9. index_select: se devuelve un tensor con índices como se mencionó, seleccionando del tensor objetivo.

Sintaxis:

torch.index_select(input, dim, index, out=None) 

Parámetros:

• input(Tensor): Tensor a partir del cual se seleccionarán los índices.
• dim(int): dimensión a lo largo de la cual seleccionar.
• índice: Contiene índices al índice.

Ejemplo 11: Tomamos 0,1 índices del tensor ‘m’ a lo largo de dim=0, es decir, filas e imprimimos la salida.

#importing libraries
import torch
  
m=torch.randn(3,4)
print('Original matrix:\n',m)
indices=torch.tensor([0,1])
print("Indexed Matrix:\n",torch.index_select(m, 0, indices))

Producción:

Original matrix:
 tensor([[ 0.2008, -0.2637,  2.1216, -0.2892],
        [-0.4059, -1.6054, -2.5022, -0.2912],
        [-0.3246,  0.4751, -0.1018, -0.6707]])
Indexed Matrix:
 tensor([[ 0.2008, -0.2637,  2.1216, -0.2892],
        [-0.4059, -1.6054, -2.5022, -0.2912]])

  Referencia: https://pytorch.org/docs/stable/tensors.html