Ordinando gli elementi di un tensore a Pytorch

Vedremo come ordinare tutti gli elementi in un tensore di Pytorch in questo tutorial Pytorch.

Pytorch è un framework open source disponibile con un linguaggio di programmazione Python. Possiamo elaborare i dati in Pytorch sotto forma di tensore. Il tensore è un array multidimensionale che viene utilizzato per archiviare i dati. Per usare un tensore, dobbiamo importare il modulo Torch. Per creare un tensore, il metodo utilizzato è tensore ().

Sintassi:

torcia.tensore (dati)

Dove i dati sono un array multidimensionale.

Torcia.ordinare()

Torcia.Sort () in Pytorch viene utilizzato per ordinare gli elementi in un tensore nell'ordine ascendente. Se il tensore è bidimensionale, risolve la riga quando specifichiamo 1. E si ordina in colonna quando specifichiamo 0.

Sintassi:
Per quanto riguarda la riga: torcia.Ordina (due_demensional_tensor_object, 1)

Per quanto riguarda la colonna: torcia.Ordina (due_demensional_tensor_object, 0)

Parametro:

1. Due_demensional_tensor_object è il tensore che ha 2 dimensioni.
2. Uno (1) si riferisce all'ordinamento a righe e 0 si riferisce all'ordinamento a colonna.

Ordina la riga per impostazione predefinita.

Ritorno:
Restituisce il tensore ordinato insieme alle posizioni dell'indice nel tensore effettivo.

Esempio 1:

Creiamo un tensore 2D che ha 5 righe e 5 colonne. Quindi, lo ordiniamo in termini di riga senza specificare un secondo parametro.

Modulo Torcia #IMport
Torcia di importazione
#Crea un tensore 2D - Data1 con 5 valori numerici in 4 righe
data1 = torcia.Tensor ([[23,45,67,0,0], [12,21,10,34,78], [3,4,5,2,3], [45,67,54,32,22] ])
#Schermo
print ("tensore:", data1)
#sort il tensore sopra
Stampa ("Dopo aver risolto la riga:")
Stampa (torcia.ordin (data1))

Produzione:

Tensor: tensore ([[23, 45, 67, 0, 0],
[12, 21, 10, 34, 78],
[3, 4, 5, 2, 3],
[45, 67, 54, 32, 22]])
Dopo aver risolto la riga:
torcia.return_types.ordinare(
valori = tensore ([[0, 0, 23, 45, 67],
[10, 12, 21, 34, 78],
[2, 3, 3, 4, 5],
[22, 32, 45, 54, 67]]),
Indici = tensore ([[3, 4, 0, 1, 2],
[2, 0, 1, 3, 4],
[3, 0, 4, 1, 2],
[4, 3, 0, 2, 1]]))

Possiamo osservare che gli elementi sono ordinati in termini di riga in un tensore in ordine crescente e restituiti gli indici delle loro posizioni nel tensore effettivo.

Esempio 2:

Creiamo un tensore 2D che ha 5 righe e 5 colonne. Quindi, lo ordiniamo in termini di riga specificando un secondo parametro come 1.

Modulo Torcia #IMport
Torcia di importazione
#Crea un tensore 2D - Data1 con 5 valori numerici in 4 righe
data1 = torcia.Tensor ([[23,45,67,0,0], [12,21,10,34,78], [3,4,5,2,3], [45,67,54,32,22] ])
#Schermo
print ("tensore:", data1)
#sort il tensore sopra
Stampa ("Dopo aver risolto la riga:")
Stampa (torcia.Ordina (data1,1))

Produzione:

Tensor: tensore ([[23, 45, 67, 0, 0],
[12, 21, 10, 34, 78],
[3, 4, 5, 2, 3],
[45, 67, 54, 32, 22]])
Dopo aver risolto la riga:
torcia.return_types.ordinare(
valori = tensore ([[0, 0, 23, 45, 67],
[10, 12, 21, 34, 78],
[2, 3, 3, 4, 5],
[22, 32, 45, 54, 67]]),
Indici = tensore ([[3, 4, 0, 1, 2],
[2, 0, 1, 3, 4],
[3, 0, 4, 1, 2],
[4, 3, 0, 2, 1]]))

Possiamo osservare che gli elementi sono ordinati in termini di riga in un tensore in ordine crescente e restituiti gli indici delle loro posizioni nel tensore effettivo.

Esempio 3:

Creiamo un tensore 2D che ha 5 righe e 5 colonne. Quindi, lo ordiniamo in termini di colonna specificando un secondo parametro come 0.

Modulo Torcia #IMport
Torcia di importazione
#Crea un tensore 2D - Data1 con 5 valori numerici in 4 righe
data1 = torcia.Tensor ([[23,45,67,0,0], [12,21,10,34,78], [3,4,5,2,3], [45,67,54,32,22] ])
#Schermo
print ("tensore:", data1)
#sort il tensore sopra
Stampa ("Dopo aver risolto la colonna:")
Stampa (torcia.Ordina (data1,0))

Produzione:

Tensor: tensore ([[23, 45, 67, 0, 0],
[12, 21, 10, 34, 78],
[3, 4, 5, 2, 3],
[45, 67, 54, 32, 22]])
Dopo aver ordinato la colonna:
torcia.return_types.ordinare(
valori = tensore ([[3, 4, 5, 0, 0],
[12, 21, 10, 2, 3],
[23, 45, 54, 32, 22],
[45, 67, 67, 34, 78]]),
Indici = tensore ([[2, 2, 2, 0, 0],
[1, 1, 1, 2, 2],
[0, 0, 3, 3, 3],
[3, 3, 0, 1, 1]]))

Possiamo osservare che gli elementi sono ordinati in termini di colonna in un tensore in ordine crescente e restituito gli indici delle loro posizioni nel tensore effettivo.

Esempio 4:

Creiamo un tensore 1D che ha 5 valori. Quindi, lo ordiniamo usando la funzione Ord ().

Modulo Torcia #IMport
Torcia di importazione
#Crea un tensore 1D - Data1 con 5 valori numerici
data1 = torcia.Tensor ([23,45,67,0,0])
#Schermo
print ("tensore:", data1)
#sort il tensore sopra
stampa ("Dopo l'ordinamento ::")
Stampa (torcia.ordin (data1))

Produzione:

Tensor: tensore ([23, 45, 67, 0, 0])
Dopo l'ordinamento ::
torcia.return_types.ordinare(
valori = tensore ([0, 0, 23, 45, 67]),
indici = tensore ([3, 4, 0, 1, 2])

Possiamo osservare che gli elementi sono ordinati in ordine crescente e restituiti gli indici delle loro posizioni nel tensore effettivo.

Lavorare con la CPU

Se si desidera eseguire una funzione di ordinamento () sulla CPU, dobbiamo creare un tensore con una funzione CPU (). Questo funzionerà su una macchina CPU.

Quando creiamo un tensore, questa volta, possiamo usare la funzione CPU ().

Sintassi:

torcia.tensore (dati).processore()

Esempio:

Creiamo un tensore 2D che ha 5 righe e 5 colonne. Quindi, lo ordiniamo in termini di riga specificando un secondo parametro come 1 e ordinarlo in termini di colonna specificando un secondo parametro come 0.

Modulo Torcia #IMport
Torcia di importazione
#Crea un tensore 2D - Data1 con 5 valori numerici in 4 righe
data1 = torcia.Tensor ([[23,45,67,0,0], [12,21,10,34,78], [3,4,5,2,3], [45,67,54,32,22] ]).processore()
#Schermo
print ("tensore:", data1)
stampa()
#sort il tensore sopra
Stampa ("Dopo aver risolto la riga:")
Stampa (torcia.Ordina (data1,1))
stampa()
#sort il tensore sopra
Stampa ("Dopo aver risolto la colonna:")
Stampa (torcia.Ordina (data1,0))

Produzione:

Tensor: tensore ([[23, 45, 67, 0, 0],
[12, 21, 10, 34, 78],
[3, 4, 5, 2, 3],
[45, 67, 54, 32, 22]])
Dopo aver risolto la riga:
torcia.return_types.ordinare(
valori = tensore ([[0, 0, 23, 45, 67],
[10, 12, 21, 34, 78],
[2, 3, 3, 4, 5],
[22, 32, 45, 54, 67]]),
Indici = tensore ([[3, 4, 0, 1, 2],
[2, 0, 1, 3, 4],
[3, 0, 4, 1, 2],
[4, 3, 0, 2, 1]]))
Dopo aver ordinato la colonna:
torcia.return_types.ordinare(
valori = tensore ([[3, 4, 5, 0, 0],
[12, 21, 10, 2, 3],
[23, 45, 54, 32, 22],
[45, 67, 67, 34, 78]]),
Indici = tensore ([[2, 2, 2, 0, 0],
[1, 1, 1, 2, 2],
[0, 0, 3, 3, 3],
[3, 3, 0, 1, 1]]))

Possiamo osservare che gli elementi sono ordinati in termini di riga e in termini di colonna in un tensore in ordine crescente e restituito gli indici delle loro posizioni nel tensore effettivo.

Conclusione

In questo tutorial di Pytorch, abbiamo imparato a ordinare gli elementi in un tensore in ordine crescente usando la torcia.Ordine () funzione. Se il tensore è bidimensionale, ordina in termini di riga quando specifichiamo 1 e ordiniamo in termini di colonna quando specifichiamo 0. Restituisce il tensore ordinato insieme alle posizioni dell'indice nel tensore effettivo.

Abbiamo imparato i diversi esempi insieme alla funzione CPU (). La torcia.La funzione Ordine () non prendi alcun parametro durante l'applicazione sul tensore 1D.