Ordenar los elementos de un tensor en Pytorch

Veremos cómo ordenar todos los elementos en un tensor Pytorch en este tutorial de Pytorch.

Pytorch es un marco de código abierto disponible con un lenguaje de programación de Python. Podemos procesar los datos en Pytorch en forma de tensor. Tensor es una matriz multidimensional que se utiliza para almacenar los datos. Para usar un tensor, tenemos que importar el módulo de antorcha. Para crear un tensor, el método utilizado es tensor ().

Sintaxis:

antorcha.Tensor (datos)

Donde los datos son una matriz multidimensional.

Antorcha.clasificar()

Antorcha.sort () en pytorch se usa para clasificar los elementos en un tensor en el orden ascendente. Si el tensor es bidimensional, clasifica en cuanto a la fila cuando especificamos 1. Y se clasifica en cuestión de columnas cuando especificamos 0.

Sintaxis:
En cuanto a la fila: antorcha.sort (two_demensional_tensor_object, 1)

Columna en cuanto a la columna: antorcha.sort (two_demensional_tensor_object, 0)

Parámetro:

1. Two_demension_tensor_object es el tensor que tiene 2 dimensiones.
2. Uno (1) se refiere a la clasificación de la fila y 0 se refiere a la clasificación de columna.

Clasifica en cuanto a fila de forma predeterminada.

Devolver:
Devuelve el tensor ordenado junto con las posiciones de índice en el tensor real.

Ejemplo 1:

Creemos un tensor 2D que tenga 5 filas y 5 columnas. Luego, lo clasificamos en cuanto a fila sin especificar un segundo parámetro.

#módulo de antorcha de Import
antorcha de importación
#cree un tensor 2D - datos1 con 5 valores numéricos en 4 filas
datos1 = antorcha.Tensor ([[23,45,67,0,0], [12,21,10,34,78], [3,4,5,2,3], [45,67,54,32,22] ])
#mostrar
Imprimir ("Tensor:", Data1)
#cre el tensor anterior
Imprimir ("Después de clasificar en cuanto a fila:")
imprimir (antorcha.Sort (Data1))

Producción:

Tensor: Tensor ([[23, 45, 67, 0, 0],
[12, 21, 10, 34, 78],
[3, 4, 5, 2, 3],
[45, 67, 54, 32, 22]])
Después de clasificar en cuanto a fila:
antorcha.return_types.clasificar(
valores = tensor ([[0, 0, 23, 45, 67],
[10, 12, 21, 34, 78],
[2, 3, 3, 4, 5],
[22, 32, 45, 54, 67]]),
índices = tensor ([[3, 4, 0, 1, 2],
[2, 0, 1, 3, 4],
[3, 0, 4, 1, 2],
[4, 3, 0, 2, 1]])

Podemos observar que los elementos se clasifican en un tensor en orden ascendente y devuelven los índices de sus posiciones en el tensor real.

Ejemplo 2:

Creemos un tensor 2D que tenga 5 filas y 5 columnas. Luego, lo clasificamos en cuanto a filas especificando un segundo parámetro como 1.

#módulo de antorcha de Import
antorcha de importación
#cree un tensor 2D - datos1 con 5 valores numéricos en 4 filas
datos1 = antorcha.Tensor ([[23,45,67,0,0], [12,21,10,34,78], [3,4,5,2,3], [45,67,54,32,22] ])
#mostrar
Imprimir ("Tensor:", Data1)
#cre el tensor anterior
Imprimir ("Después de clasificar en cuanto a fila:")
imprimir (antorcha.Sort (Data1,1))

Producción:

Tensor: Tensor ([[23, 45, 67, 0, 0],
[12, 21, 10, 34, 78],
[3, 4, 5, 2, 3],
[45, 67, 54, 32, 22]])
Después de clasificar en cuanto a fila:
antorcha.return_types.clasificar(
valores = tensor ([[0, 0, 23, 45, 67],
[10, 12, 21, 34, 78],
[2, 3, 3, 4, 5],
[22, 32, 45, 54, 67]]),
índices = tensor ([[3, 4, 0, 1, 2],
[2, 0, 1, 3, 4],
[3, 0, 4, 1, 2],
[4, 3, 0, 2, 1]])

Podemos observar que los elementos se clasifican en un tensor en orden ascendente y devuelven los índices de sus posiciones en el tensor real.

Ejemplo 3:

Creemos un tensor 2D que tenga 5 filas y 5 columnas. Luego, lo clasificamos en cuanto a columna especificando un segundo parámetro como 0.

#módulo de antorcha de Import
antorcha de importación
#cree un tensor 2D - datos1 con 5 valores numéricos en 4 filas
datos1 = antorcha.Tensor ([[23,45,67,0,0], [12,21,10,34,78], [3,4,5,2,3], [45,67,54,32,22] ])
#mostrar
Imprimir ("Tensor:", Data1)
#cre el tensor anterior
Imprimir ("Después de clasificar la columna:")
imprimir (antorcha.Sort (Data1,0))

Producción:

Tensor: Tensor ([[23, 45, 67, 0, 0],
[12, 21, 10, 34, 78],
[3, 4, 5, 2, 3],
[45, 67, 54, 32, 22]])
Después de clasificar la columna:
antorcha.return_types.clasificar(
valores = tensor ([[3, 4, 5, 0, 0],
[12, 21, 10, 2, 3],
[23, 45, 54, 32, 22],
[45, 67, 67, 34, 78]]),
índices = tensor ([[2, 2, 2, 0, 0],
[1, 1, 1, 2, 2],
[0, 0, 3, 3, 3],
[3, 3, 0, 1, 1]])

Podemos observar que los elementos se clasifican en un tensor en orden ascendente y devuelven los índices de sus posiciones en el tensor real.

Ejemplo 4:

Creemos un tensor 1D que tenga 5 valores. Luego, lo clasificamos usando la función sort ().

#módulo de antorcha de Import
antorcha de importación
#cree un tensor 1D - datos1 con 5 valores numéricos
datos1 = antorcha.Tensor ([23,45,67,0,0])
#mostrar
Imprimir ("Tensor:", Data1)
#cre el tensor anterior
Imprimir ("Después de clasificar ::")
imprimir (antorcha.Sort (Data1))

Producción:

Tensor: Tensor ([23, 45, 67, 0, 0])
Después de clasificar ::
antorcha.return_types.clasificar(
valores = tensor ([0, 0, 23, 45, 67]),
índices = tensor ([3, 4, 0, 1, 2]))

Podemos observar que los elementos se clasifican en orden ascendente y devuelven los índices de sus posiciones en el tensor real.

Trabajar con CPU

Si desea ejecutar una función sort () en la CPU, tenemos que crear un tensor con una función CPU (). Esto se ejecutará en una máquina CPU.

Cuando creamos un tensor, esta vez, podemos usar la función CPU ().

Sintaxis:

antorcha.Tensor (datos).UPC()

Ejemplo:

Creemos un tensor 2D que tenga 5 filas y 5 columnas. Luego, lo clasificamos en cuanto a fila especificando un segundo parámetro como 1 y lo ordenamos especificando un segundo parámetro como 0.

#módulo de antorcha de Import
antorcha de importación
#cree un tensor 2D - datos1 con 5 valores numéricos en 4 filas
datos1 = antorcha.Tensor ([[23,45,67,0,0], [12,21,10,34,78], [3,4,5,2,3], [45,67,54,32,22] ]).UPC()
#mostrar
Imprimir ("Tensor:", Data1)
imprimir()
#cre el tensor anterior
Imprimir ("Después de clasificar en cuanto a fila:")
imprimir (antorcha.Sort (Data1,1))
imprimir()
#cre el tensor anterior
Imprimir ("Después de clasificar la columna:")
imprimir (antorcha.Sort (Data1,0))

Producción:

Tensor: Tensor ([[23, 45, 67, 0, 0],
[12, 21, 10, 34, 78],
[3, 4, 5, 2, 3],
[45, 67, 54, 32, 22]])
Después de clasificar en cuanto a fila:
antorcha.return_types.clasificar(
valores = tensor ([[0, 0, 23, 45, 67],
[10, 12, 21, 34, 78],
[2, 3, 3, 4, 5],
[22, 32, 45, 54, 67]]),
índices = tensor ([[3, 4, 0, 1, 2],
[2, 0, 1, 3, 4],
[3, 0, 4, 1, 2],
[4, 3, 0, 2, 1]])
Después de clasificar la columna:
antorcha.return_types.clasificar(
valores = tensor ([[3, 4, 5, 0, 0],
[12, 21, 10, 2, 3],
[23, 45, 54, 32, 22],
[45, 67, 67, 34, 78]]),
índices = tensor ([[2, 2, 2, 0, 0],
[1, 1, 1, 2, 2],
[0, 0, 3, 3, 3],
[3, 3, 0, 1, 1]])

Podemos observar que los elementos están ordenados en cuanto a hileras y en cuanto a columnas en un tensor en orden ascendente y devuelven los índices de sus posiciones en el tensor real.

Conclusión

En este tutorial de Pytorch, aprendimos cómo ordenar los elementos en un tensor en orden ascendente usando la antorcha.función () función. Si el tensor es bidimensional, clasifica en cuanto a la fila cuando especificamos 1 y clasifica en cuanto a columna cuando especificamos 0. Devuelve el tensor ordenado junto con las posiciones de índice en el tensor real.

Aprendimos los diferentes ejemplos junto con la función CPU (). La antorcha.Función sort () No tome ningún parámetro al aplicarlo en el tensor 1D.