[PyTroch系列-11]：PyTorch基础 - 张量元素的排序

作者主页(文火冰糖的硅基工坊)：https://blog.csdn.net/HiWangWenBing

作者主页(文火冰糖的硅基工坊)：https://blog.csdn.net/HiWangWenBing

本文网址：https://blog.csdn.net/HiWangWenBing/article/details/119459192

---

目录

第1章 Tensor运算概述

1.1 概述

1.3  “in place“运算 

1.4 Tensor的广播机制: 不同维度的张量运算

1.5 环境准备

1.6 排序运算概述

第2章 代码示例：sort（排序）

第3章 代码示例：topk（获取前K个最值）

第4章 代码示例：kthvalue（取第K个最小值）

---

---

第1章 Tensor运算概述

1.1 概述

PyTorch提供了大量的张量运算，基本上可以对标Numpy多维数组的运算，以支持对张量的各种复杂的运算。

这些操作运算中大多是对数组中每个元素执行相同的函数运算，并获得每个元素函数运算的结果序列，这些序列生成一个新的同维度的数组。

https://www.runoob.com/numpy/numpy-linear-algebra.html

1.2 运算分类

（1）算术运算：加、减、系数乘、系数除

（2）函数运算：sin，cos

（3）取整运算：上取整、下取整

（4）统计运算：最大值、最小值、均值

（5）比较运算：大于，等于，小于、排序

（6）线性代数运算：矩阵、点乘、叉乘

1.3  “in place“运算 

“in place“运算不是某个特定的函数运算，而是每个函数都有自己的“in place“运算的版本。

xxx_()：执行完该操作，直接修改tensor自身的值。

基本上，每个函数都有自己的in place版本。

如

torch.cos() =》torch.cos_()

torch.floor() =》torch.floor_()

1.4 Tensor的广播机制: 不同维度的张量运算

1.5 环境准备

import numpy as np
import torch
 
print("Hello World")
print(torch.__version__)
print(torch.cuda.is_available())

1.6 排序运算概述

（1） sort：排序

• 可以按照不同的张量维度进行排序，有dim指定。
• 可以按照升序或降序排序，有descending进行排序。
• out：存储输出结果的张量

（2）topk：获取前K个元素。

• k：要获取的元素的个数
• dim：指定dim方向，而不是全部元素
• largest：取最大元素还是最小元素
• sorted：向量是否已经排序，如果未排序，该函数先对张量进行排序。
• out：存储输出结果的张量

（3）kthvalue：获取第K个最小值

• k：指定待获取元素的序号
• dim：指定操作的张量维度方向
• out：存储输出结果的张量

第2章 代码示例：sort（排序）

# 排序sort

a = torch.Tensor([[5,4,1],[6,3,2]])  
print ("源数据：")
print (a)
print ('\n')

print("默认排序")
print(torch.sort(a))

print("\ndim=1排序")
print(torch.sort(a,dim=1))

print("\ndim=0排序")
print(torch.sort(a,dim=0))

print("\n成员函数排序")
print(a.sort(dim=1, descending = True))
print ("\n源数据：")
print(a)

#输出：

源数据：
tensor([[5., 4., 1.],
        [6., 3., 2.]])


默认排序
torch.return_types.sort(
values=tensor([[1., 4., 5.],
        [2., 3., 6.]]),
indices=tensor([[2, 1, 0],
        [2, 1, 0]]))

dim=1排序
torch.return_types.sort(
values=tensor([[1., 4., 5.],
        [2., 3., 6.]]),
indices=tensor([[2, 1, 0],
        [2, 1, 0]]))

dim=0排序
torch.return_types.sort(
values=tensor([[5., 3., 1.],
        [6., 4., 2.]]),
indices=tensor([[0, 1, 0],
        [1, 0, 1]]))

成员函数排序
torch.return_types.sort(
values=tensor([[5., 4., 1.],
        [6., 3., 2.]]),
indices=tensor([[0, 1, 2],
        [0, 1, 2]]))

源数据：
tensor([[5., 4., 1.],
        [6., 3., 2.]])

备注：

• 默认是按照dim = 1的方向进行排序
• 默认是按照升序排序
• 排序后，不影响源张量的数据
• 可以通过torch.sort排序，也可以通过张量的成员函数a.sort进行排序

• dim = 1：对每个行向量进行排序
• dim = 1：对每个列向量进行排序

第3章 代码示例：topk（获取前K个最值）

# topk

a = torch.Tensor([[2,4,6,12,8,10],[1,1,5,11,11,9]])  
print ("源数据：")
print (a)

print ("\n默认参数：")
print(torch.topk(a,2))

print ("\n取K个最大值：")
b = torch.topk(a,k=2, largest=True)
print(b)

print ("\n取K个最小值：")
torch.topk(a,k=2, largest=False, out=b)
print(b)

输出：

源数据：
tensor([[ 2.,  4.,  6., 12.,  8., 10.],
        [ 1.,  1.,  5., 11., 11.,  9.]])

默认参数：
torch.return_types.topk(
values=tensor([[12., 10.],
        [11., 11.]]),
indices=tensor([[3, 5],
        [3, 4]]))

取K个最大值：
torch.return_types.topk(
values=tensor([[12., 10.],
        [11., 11.]]),
indices=tensor([[3, 5],
        [3, 4]]))

取K个最小值：
torch.return_types.topk(
values=tensor([[2., 4.],
        [1., 1.]]),
indices=tensor([[0, 1],
        [0, 1]]))

备注：

• 对于值相同的元素，依然参与排序，并不剔除值相同的元素。
• 默认是k个最大值
• 操作后，对源张量数据无影响

第4章 代码示例：kthvalue（取第K个最小值）

# kthvalue：取第K个排序后的元素

a = torch.Tensor([[2,4,6,12,8,0],[3,7,5,11,1,9]])  
print ("源数据：")
print (a)

print ("\n源数据排序后的值：")
print (torch.sort(a))

print ("\n默认参数取第3个最小值：：")
print(torch.kthvalue(a,3))

print ("\n按dim=1的方向取第3个最小值：")
b = torch.kthvalue(a,k=3, dim=1)
print(b)

print ("\n按dim=0的方向取第1个最小值：")
torch.kthvalue(a, k=1, dim=0, out=b)
print(b)

输出：

源数据：
tensor([[ 2.,  4.,  6., 12.,  8.,  0.],
        [ 3.,  7.,  5., 11.,  1.,  9.]])

源数据排序后的值：
torch.return_types.sort(
values=tensor([[ 0.,  2.,  4.,  6.,  8., 12.],
        [ 1.,  3.,  5.,  7.,  9., 11.]]),
indices=tensor([[5, 0, 1, 2, 4, 3],
        [4, 0, 2, 1, 5, 3]]))

默认参数取第3个最小值：：
torch.return_types.kthvalue(
values=tensor([4., 5.]),
indices=tensor([1, 2]))

按dim=1的方向取第3个最小值：
torch.return_types.kthvalue(
values=tensor([4., 5.]),
indices=tensor([1, 2]))

按dim=0的方向取第1个最小值：
torch.return_types.kthvalue(
values=tensor([ 2.,  4.,  5., 11.,  1.,  0.]),
indices=tensor([0, 0, 1, 1, 1, 0]))

输出：


源数据：
tensor([[ 2.,  4.,  6., 12.,  8.,  0.],
        [ 3.,  7.,  5., 11.,  1.,  9.]])

源数据排序后的值：
torch.return_types.sort(
values=tensor([[ 0.,  2.,  4.,  6.,  8., 12.],
               [ 1.,  3.,  5.,  7.,  9., 11.]]),
indices=tensor([[5, 0, 1, 2, 4, 3],
                [4, 0, 2, 1, 5, 3]]))

默认参数取第3个最小值：：
torch.return_types.kthvalue(
values=tensor([4., 5.]),
indices=tensor([1, 2]))

按dim=1的方向取第3个最小值：
torch.return_types.kthvalue(
values=tensor([4., 5.]),
indices=tensor([1, 2]))

按dim=0的方向取第1个最小值：
torch.return_types.kthvalue(
values=tensor([ 2.,  4.,  5., 11.,  1.,  0.]),
indices=tensor([0, 0, 1, 1, 1, 0]))

备注：

• 默认是按照dim = 1的方向，即从行向量的序列中进行比较。
• 在dim指定的方向的序列中，取第K个排序后的最小值。也就意味着该操作是对序列进行升序排列。

---

作者主页(文火冰糖的硅基工坊)：https://blog.csdn.net/HiWangWenBing

本文网址：https://blog.csdn.net/HiWangWenBing/article/details/119459192