Classificando os elementos de um tensor em pytorch

Veremos como classificar todos os elementos em um tensor pytorch neste tutorial de pytorch.

Pytorch é uma estrutura de código aberto disponível com uma linguagem de programação Python. Podemos processar os dados em pytorch na forma de um tensor. Tensor é uma matriz multidimensional usada para armazenar os dados. Para usar um tensor, temos que importar o módulo da tocha. Para criar um tensor, o método usado é tensor ().

Sintaxe:

tocha.Tensor (dados)

Onde os dados são uma matriz multidimensional.

Tocha.organizar()

Tocha.Sort () em Pytorch é usado para classificar os elementos em um tensor na ordem ascendente. Se o tensor for bidimensional, ele classifica em termos de remar quando especificarmos 1. E isso classifica em coluna quando especificamos 0.

Sintaxe:
Row Wise: tocha.Sort (Two_Demensional_tensor_Object, 1)

Em termos de coluna: tocha.Sort (Two_Demensional_tensor_Object, 0)

Parâmetro:

1. Two_Demensional_tensor_Object é o tensor que possui 2 dimensões.
2. Um (1) refere-se à classificação em remar e 0 refere-se à classificação em colunas.

Ele classifica em termos de remar por padrão.

Retornar:
Ele retorna o tensor classificado junto com as posições de índice no tensor real.

Exemplo 1:

Vamos criar um tensor 2D que tenha 5 linhas e 5 colunas. Em seguida, nós classificamos em termos de remar sem especificar um segundo parâmetro.

#import módulo tocha
importação de tocha
#Crie um tensor 2D - Data1 com 5 valores numéricos em 4 linhas
Data1 = Torch.tensor ([[23,45,67,0,0], [12,21,10,34,78], [3,4,5,2,3], [45,67,54,32,22] ]))
#mostrar
print ("tensor:", data1)
#sort o tensor acima
Imprima ("Depois de classificar em termos de linha:")
Imprimir (tocha.classificar (Data1))

Saída:

Tensor: Tensor ([[23, 45, 67, 0, 0],
[12, 21, 10, 34, 78],
[3, 4, 5, 2, 3],
[45, 67, 54, 32, 22]])
Depois de classificar em termos de remar:
tocha.return_types.organizar(
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 os elementos são classificados em termos de remar em um tensor em ordem ascendente e devolveram os índices de suas posições no tensor real.

Exemplo 2:

Vamos criar um tensor 2D que tenha 5 linhas e 5 colunas. Então, nós classificamos isso em termos de linha, especificando um segundo parâmetro como 1.

#import módulo tocha
importação de tocha
#Crie um tensor 2D - Data1 com 5 valores numéricos em 4 linhas
Data1 = Torch.tensor ([[23,45,67,0,0], [12,21,10,34,78], [3,4,5,2,3], [45,67,54,32,22] ]))
#mostrar
print ("tensor:", data1)
#sort o tensor acima
Imprima ("Depois de classificar em termos de linha:")
Imprimir (tocha.classificar (Data1,1))

Saída:

Tensor: Tensor ([[23, 45, 67, 0, 0],
[12, 21, 10, 34, 78],
[3, 4, 5, 2, 3],
[45, 67, 54, 32, 22]])
Depois de classificar em termos de remar:
tocha.return_types.organizar(
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 os elementos são classificados em termos de remar em um tensor em ordem ascendente e devolveram os índices de suas posições no tensor real.

Exemplo 3:

Vamos criar um tensor 2D que tenha 5 linhas e 5 colunas. Em seguida, classificamos em termos de coluna especificando um segundo parâmetro como 0.

#import módulo tocha
importação de tocha
#Crie um tensor 2D - Data1 com 5 valores numéricos em 4 linhas
Data1 = Torch.tensor ([[23,45,67,0,0], [12,21,10,34,78], [3,4,5,2,3], [45,67,54,32,22] ]))
#mostrar
print ("tensor:", data1)
#sort o tensor acima
print ("Depois de classificar em termos de coluna:")
Imprimir (tocha.classificar (Data1,0))

Saída:

Tensor: Tensor ([[23, 45, 67, 0, 0],
[12, 21, 10, 34, 78],
[3, 4, 5, 2, 3],
[45, 67, 54, 32, 22]])
Depois de classificar em termos de coluna:
tocha.return_types.organizar(
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 os elementos são classificados em termos de coluna em um tensor em ordem ascendente e devolveram os índices de suas posições no tensor real.

Exemplo 4:

Vamos criar um tensor 1D que tenha 5 valores. Então, nós classificamos isso usando a função Sort ().

#import módulo tocha
importação de tocha
#Crie um tensor 1D - Data1 com 5 valores numéricos
Data1 = Torch.Tensor ([23,45,67,0,0])
#mostrar
print ("tensor:", data1)
#sort o tensor acima
print ("Depois de classificar ::")
Imprimir (tocha.classificar (Data1))

Saída:

Tensor: Tensor ([23, 45, 67, 0, 0])
Depois de classificar ::
tocha.return_types.organizar(
valores = tensor ([0, 0, 23, 45, 67]),
índices = tensor ([3, 4, 0, 1, 2])))

Podemos observar que os elementos são classificados em ordem ascendente e devolveram os índices de suas posições no tensor real.

Trabalhe com a CPU

Se você deseja executar uma função Sort () na CPU, temos que criar um tensor com uma função CPU (). Isso será executado em uma máquina de CPU.

Quando criamos um tensor, desta vez, podemos usar a função CPU ().

Sintaxe:

tocha.Tensor (dados).CPU()

Exemplo:

Vamos criar um tensor 2D que tenha 5 linhas e 5 colunas. Em seguida, classificamos-o em termos de linha especificando um segundo parâmetro como 1 e classificam-o em termos de coluna, especificando um segundo parâmetro como 0.

#import módulo tocha
importação de tocha
#Crie um tensor 2D - Data1 com 5 valores numéricos em 4 linhas
Data1 = Torch.tensor ([[23,45,67,0,0], [12,21,10,34,78], [3,4,5,2,3], [45,67,54,32,22] ])).CPU()
#mostrar
print ("tensor:", data1)
imprimir()
#sort o tensor acima
Imprima ("Depois de classificar em termos de linha:")
Imprimir (tocha.classificar (Data1,1))
imprimir()
#sort o tensor acima
print ("Depois de classificar em termos de coluna:")
Imprimir (tocha.classificar (Data1,0))

Saída:

Tensor: Tensor ([[23, 45, 67, 0, 0],
[12, 21, 10, 34, 78],
[3, 4, 5, 2, 3],
[45, 67, 54, 32, 22]])
Depois de classificar em termos de remar:
tocha.return_types.organizar(
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]]))
Depois de classificar em termos de coluna:
tocha.return_types.organizar(
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 os elementos são classificados em termos de remar e colunas em um tensor em ordem crescente e devolveram os índices de suas posições no tensor real.

Conclusão

Neste tutorial de Pytorch, aprendemos a classificar os elementos em um tensor em ordem crescente usando a tocha.Sort () função. Se o tensor for bidimensional, ele classifica em termos de remar quando especificamos 1 e classifica a coluna quando especificamos 0. Ele retorna o tensor classificado junto com as posições de índice no tensor real.

Aprendemos os diferentes exemplos junto com a função CPU (). A tocha.a função Sort () não pegue nenhum parâmetro enquanto a aplica no tensor 1D.