Tri les éléments d'un tenseur à Pytorch

Nous verrons comment trier tous les éléments dans un tenseur de pytorch dans ce tutoriel pytorch.

Pytorch est un cadre open source disponible avec un langage de programmation Python. Nous pouvons traiter les données en pytorch sous la forme d'un tenseur. Tensor est un tableau multidimensionnel utilisé pour stocker les données. Pour utiliser un tenseur, nous devons importer le module de torche. Pour créer un tenseur, la méthode utilisée est tenseur ().

Syntaxe:

torche.tenseur (données)

Où les données sont un tableau multidimensionnel.

Torche.trier()

Torche.tri () dans pytorch est utilisé pour trier les éléments dans un tenseur dans l'ordre ascendant. Si le tenseur est bidimensionnel, il trie le rang lorsque nous spécifions 1. Et il trie en termes de colonne lorsque nous spécifions 0.

Syntaxe:
Row Wise: torche.Trier (Two_demensional_tensor_Object, 1)

Par colonne: torche.Trie (Two_demensional_tensor_Object, 0)

Paramètre:

1. Two_demensional_tensor_Object est le tenseur qui a 2 dimensions.
2. Un (1) fait référence au tri des lignes et 0 fait référence au tri des colonnes.

Il trie en termes de ligne par défaut.

Retour:
Il renvoie le tenseur trié avec les positions d'index dans le tenseur réel.

Exemple 1:

Créons un tenseur 2D qui a 5 lignes et 5 colonnes. Ensuite, nous le trierons en termes de lignes sans spécifier un deuxième paramètre.

Module de torche #mport
Importer une torche
#create un tenseur 2D - data1 avec 5 valeurs numériques en 4 lignes
data1 = torche.Tensor ([[23,45,67,0,0], [12,21,10,34,78], [3,4,5,2,3], [45,67,54,32,22] ])
#afficher
imprimer ("Tensor:", data1)
#Sort le tenseur ci-dessus
Imprimer ("après avoir triage sur la ligne:")
imprimer (torche.tri (data1))

Sortir:

Tensor: Tensor ([[23, 45, 67, 0, 0],
[12, 21, 10, 34, 78],
[3, 4, 5, 2, 3],
[45, 67, 54, 32, 22]])
Après avoir triage sur la ligne:
torche.return_types.trier(
valeurs = tenseur ([[0, 0, 23, 45, 67],
[10, 12, 21, 34, 78],
[2, 3, 3, 4, 5],
[22, 32, 45, 54, 67]]),
Indices = tenseur ([[3, 4, 0, 1, 2],
[2, 0, 1, 3, 4],
[3, 0, 4, 1, 2],
[4, 3, 0, 2, 1]]))

Nous pouvons observer que les éléments sont triés en ligne dans un tenseur dans l'ordre croissant et ont renvoyé les indices de leurs positions dans le tenseur réel.

Exemple 2:

Créons un tenseur 2D qui a 5 lignes et 5 colonnes. Ensuite, nous le trierons au niveau de la ligne en spécifiant un deuxième paramètre comme 1.

Module de torche #mport
Importer une torche
#create un tenseur 2D - data1 avec 5 valeurs numériques en 4 lignes
data1 = torche.Tensor ([[23,45,67,0,0], [12,21,10,34,78], [3,4,5,2,3], [45,67,54,32,22] ])
#afficher
imprimer ("Tensor:", data1)
#Sort le tenseur ci-dessus
Imprimer ("après avoir triage sur la ligne:")
imprimer (torche.tri (data1,1))

Sortir:

Tensor: Tensor ([[23, 45, 67, 0, 0],
[12, 21, 10, 34, 78],
[3, 4, 5, 2, 3],
[45, 67, 54, 32, 22]])
Après avoir triage sur la ligne:
torche.return_types.trier(
valeurs = tenseur ([[0, 0, 23, 45, 67],
[10, 12, 21, 34, 78],
[2, 3, 3, 4, 5],
[22, 32, 45, 54, 67]]),
Indices = tenseur ([[3, 4, 0, 1, 2],
[2, 0, 1, 3, 4],
[3, 0, 4, 1, 2],
[4, 3, 0, 2, 1]]))

Nous pouvons observer que les éléments sont triés en ligne dans un tenseur dans l'ordre croissant et ont renvoyé les indices de leurs positions dans le tenseur réel.

Exemple 3:

Créons un tenseur 2D qui a 5 lignes et 5 colonnes. Ensuite, nous le trierons en termes de colonne en spécifiant un deuxième paramètre comme 0.

Module de torche #mport
Importer une torche
#create un tenseur 2D - data1 avec 5 valeurs numériques en 4 lignes
data1 = torche.Tensor ([[23,45,67,0,0], [12,21,10,34,78], [3,4,5,2,3], [45,67,54,32,22] ])
#afficher
imprimer ("Tensor:", data1)
#Sort le tenseur ci-dessus
Imprimer ("après avoir trié la colonne:")
imprimer (torche.tri (data1,0))

Sortir:

Tensor: Tensor ([[23, 45, 67, 0, 0],
[12, 21, 10, 34, 78],
[3, 4, 5, 2, 3],
[45, 67, 54, 32, 22]])
Après avoir trié la colonne:
torche.return_types.trier(
valeurs = tenseur ([[3, 4, 5, 0, 0],
[12, 21, 10, 2, 3],
[23, 45, 54, 32, 22],
[45, 67, 67, 34, 78]]),
Indices = tenseur ([[2, 2, 2, 0, 0],
[1, 1, 1, 2, 2],
[0, 0, 3, 3, 3],
[3, 3, 0, 1, 1]]))

Nous pouvons observer que les éléments sont triés en termes de colonne dans un tenseur dans l'ordre croissant et ont renvoyé les indices de leurs positions dans le tenseur réel.

Exemple 4:

Créons un tenseur 1D qui a 5 valeurs. Ensuite, nous le trierons en utilisant la fonction tri ().

Module de torche #mport
Importer une torche
#create un tenseur 1D - data1 avec 5 valeurs numériques
data1 = torche.Tensor ([23,45,67,0,0])
#afficher
imprimer ("Tensor:", data1)
#Sort le tenseur ci-dessus
imprimer ("après tri ::")
imprimer (torche.tri (data1))

Sortir:

Tensor: tenseur ([23, 45, 67, 0, 0])
Après le tri ::
torche.return_types.trier(
valeurs = tenseur ([0, 0, 23, 45, 67]),
Indices = tenseur ([3, 4, 0, 1, 2]))

Nous pouvons observer que les éléments sont triés par ordre croissant et ont rendu les indices de leurs positions dans le tenseur réel.

Travailler avec le processeur

Si vous souhaitez exécuter une fonction tri () sur le CPU, nous devons créer un tenseur avec une fonction CPU (). Cela fonctionnera sur une machine CPU.

Lorsque nous créons un tenseur, cette fois, nous pouvons utiliser la fonction CPU ().

Syntaxe:

torche.tenseur (données).CPU()

Exemple:

Créons un tenseur 2D qui a 5 lignes et 5 colonnes. Ensuite, nous le trierons en ligne de ligne en spécifiant un deuxième paramètre comme 1 et en le triez en termes de colonne en spécifiant un deuxième paramètre comme 0.

Module de torche #mport
Importer une torche
#create un tenseur 2D - data1 avec 5 valeurs numériques en 4 lignes
data1 = torche.Tensor ([[23,45,67,0,0], [12,21,10,34,78], [3,4,5,2,3], [45,67,54,32,22] ]).CPU()
#afficher
imprimer ("Tensor:", data1)
imprimer()
#Sort le tenseur ci-dessus
Imprimer ("après avoir triage sur la ligne:")
imprimer (torche.tri (data1,1))
imprimer()
#Sort le tenseur ci-dessus
Imprimer ("après avoir trié la colonne:")
imprimer (torche.tri (data1,0))

Sortir:

Tensor: Tensor ([[23, 45, 67, 0, 0],
[12, 21, 10, 34, 78],
[3, 4, 5, 2, 3],
[45, 67, 54, 32, 22]])
Après avoir triage sur la ligne:
torche.return_types.trier(
valeurs = tenseur ([[0, 0, 23, 45, 67],
[10, 12, 21, 34, 78],
[2, 3, 3, 4, 5],
[22, 32, 45, 54, 67]]),
Indices = tenseur ([[3, 4, 0, 1, 2],
[2, 0, 1, 3, 4],
[3, 0, 4, 1, 2],
[4, 3, 0, 2, 1]]))
Après avoir trié la colonne:
torche.return_types.trier(
valeurs = tenseur ([[3, 4, 5, 0, 0],
[12, 21, 10, 2, 3],
[23, 45, 54, 32, 22],
[45, 67, 67, 34, 78]]),
Indices = tenseur ([[2, 2, 2, 0, 0],
[1, 1, 1, 2, 2],
[0, 0, 3, 3, 3],
[3, 3, 0, 1, 1]]))

Nous pouvons observer que les éléments sont triés au niveau des lignes et en colonne dans un tenseur dans l'ordre croissant et ont renvoyé les indices de leurs positions dans le tenseur réel.

Conclusion

Dans ce didacticiel Pytorch, nous avons appris à trier les éléments dans un tenseur dans l'ordre croissant en utilisant le flambeau.fonction Sult (). Si le tenseur est bidimensionnel, il trie le rang lorsque nous spécifions 1 et trie en termes de colonne lorsque nous spécifions 0. Il renvoie le tenseur trié avec les positions d'index dans le tenseur réel.

Nous avons appris les différents exemples avec la fonction CPU (). La torche.fonction () ne prenez aucun paramètre lors de l'application sur le tenseur 1D.