目录
- python和Pytorch数据类型
- pytorch数据类型
- 创建Tensor
- Tensor的索引和切片
- Tensor维度的变换
- Tensor的广播/自动扩展
- Tensor的合并与分割
- Tensor的数学运算
- Tensor的统计属性
- Tensor的高阶操作
python和Pytorch数据类型
pytorch不支持string.
处理string：
one-hot， Embedding，
pytorch数据类型
pytorch类型推断
维度为0的标量
标量判断
返回tensor形状/维度，形状维度个数为0则为一个Tensor：
维度为1的向量 Linear input
维度为2的tensor Linear input batch
维度为3的tensor RNN input
维度为4的tensor CNN input
其它的
a.shape 获得形状
a.numel() 获得tensor占用内存
a.dim() 返回向量维度
创建Tensor
从numpy中引入 torch.from_numpy()
import numpy as np
import torch
a = np.array([1,2,3])
t = torch.from_numpy(a)
print(t)
print(t.type())
输出：
tensor([1, 2, 3], dtype=torch.int32)
torch.IntTensor
从list中导入 torch.tensor()
import torch
a = torch.tensor([1,2,3,4])
print(a)
print(a.type())
输出：
tensor([1, 2, 3, 4])
torch.LongTensor
生成未初始化的tensor torch.empty()
生成的tensor里面的数据是不规则的数据（非常大，非常小，或者为0）。
生成数据类型为pytorch默认的数据类型。
后续一定要将未初始化的tensor的数据覆盖掉，否则容易出现nan，inf的情况。
设置默认数据类型 torch.set_default_tensor_type()
torch.Tensor() 生成的数据为默认数据类型
生成随机初始化tensor torch.rand randn
torch.rand(shape) 生成数据为0-1之间的均匀分布
torch.rand_like(a) 将a的shape赋值给rand函数，生成与a形状一样的随机tensor
torch.randint( min, max，shape_list) 生成[min, max)之间的随机整数。
import torch
a = torch.rand(3,3)
b = torch.rand_like(a)
c = torch.randint(10,20,[3,3])
print(a)
print(b)
print(c)
输出：
tensor([[0.2608, 0.3953, 0.7723],
[0.1387, 0.5454, 0.2346],
[0.6234, 0.1312, 0.8868]])
tensor([[0.0888, 0.2244, 0.1465],
[0.9179, 0.8248, 0.4669],
[0.5843, 0.0690, 0.3438]])
tensor([[14, 14, 18],
[14, 16, 18],
[13, 16, 19]])
生成符合正太分布的随机数
torch.randn() 默认服从0-1正态分布。
torch.normal(mean,std) 指定均值和方差。
将tensor全服赋值为1个元素 torch.fulll
torch.full(shape, value) 生成元素全为value的指定shape的tensor
import torch
a = torch.full([2,3], 7)
b = torch.full([], 7) #生成一个标量，值7
print(a)
print(b)
print(a.type()
输出：
tensor([[7, 7, 7],
[7, 7, 7]])
tensor(7)
torch.LongTensor
递增递减生成等差数据 torch.arange
torch.arange(min, max, step) step为步长
import torch
a = torch.arange(0,10,2)
print(a)
输出：
tensor([0, 2, 4, 6, 8])
torch.linspace(left, right, steps) 生成等分数据 step为数据的数量
torch.logspace(left, right, steps) left到right之间切割 base参数可以设置为2,10,e等参数。
import torch
a = torch.linspace(0,10,3)
print(a)
a = torch.linspace(0,10,7) #0-10等分切割10个数
print(a)
b = torch.logspace(0,-1, 10) #生成10^0 ~ 10 ^(-1)之间的等分数据
print(b)
输出：
tensor([ 0., 5., 10.])
tensor([ 0.0000, 1.6667, 3.3333, 5.0000, 6.6667, 8.3333, 10.0000])
tensor([1.0000, 0.7743, 0.5995, 0.4642, 0.3594, 0.2783, 0.2154, 0.1668, 0.1292,
0.1000])
生成全零全一，单位矩阵的数据 torch.Ones/zeros/eye()
torch.Ones/zeros/eye()
import torch
a = torch.ones(3,4)
b = torch.zeros(3,3)
c = torch.eye(4)
print(a)
print(b)
print(c)
输出：
tensor([[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]])
tensor([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])
tensor([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])
随机打散一个范围内的数据 torch.randperm
torch.randperm(n) 生成[0,n)之间的打乱的数据
import torch
idx = torch.randperm(5)
print(idx)
输出：
tensor([3, 0, 2, 4, 1])
Tensor的索引和切片
Tensor的索引和python的索引相似。
索引，首先索引第0维数据。
直接索引
连续索引
索引+步长
…任意的维度
a[…] = a[:,:,:,:]
a[0,…] = a[0,:,:,:]
a[:,1, …] = a[:,1,:,:]
a[…,:2] = a[:,:,:,:2]
a[0,…,::2] = a[0,:,:,::2]
获取指定维度上的指定索引
a.index_select(dim, indexes) 表示在哪一个维度上进行索引
import torch
a = torch.randn(4,3,28,28)
b = a.index_select(2,torch.arange(20)) #选取所有图像前20行
c = a.index_select(0,torch.tensor([0,2])) #选取第0和第二2张图像， 第二个参数index必须为tensor
print(b.size())
print(c.size())
输出：
torch.Size([4, 3, 20, 28])
torch.Size([2, 3, 28, 28])
使用掩码的索引
torch.masked_select()
import torch
a = torch.randn(3,4)
mask = a.ge(0.5)
b = a.masked_select(mask)
print(a)
print(mask)
print(b)
输出：
tensor([[-1.4989, 0.7418, 1.5531, -0.4406],
[-0.2969, 0.3999, 0.4586, 1.0370],
[ 0.0624, 1.5981, 0.8669, 2.3349]])
tensor([[False, True, True, False],
[False, False, False, True],
[False, True, True, True]])
tensor([0.7418, 1.5531, 1.0370, 1.5981, 0.8669, 2.3349])
使用展平的的索引
torch.take() 将tensor先展平，然后通过展平后来索引，使用频率不高。
import torch
a = torch.randn(3,4)
b = a.take(torch.tensor([0,6]))
print(a)
print(b)
输出：
tensor([[ 0.0684, 0.1547, -0.0695, 1.0046],
[ 0.0481, -0.7794, 0.1260, 0.3270],
[ 0.1343, -0.3111, -1.1746, -0.6975]])
tensor([0.0684, 0.1260])
Tensor维度的变换
view/reshape在Tensor元素个数不变情况下，将一个shape转换为另一个shape。
Squeeze 删减维度 unsqueeze 增加维度
Transpose/t/permute
Expand/repeat 增加维度
shape转换 view/reshape
保证numel()一致就可以随意shape转换。
import torch
a = torch.randn(4, 1, 28, 28) #假设为MINIST数据集
print(a.shape)
b = a.view(4 ,28,28)
print(b.shape)
c = a.view(4,28*28) #将图像展平
print(c.shape)
d = a.view(4*28, 28) #关注所有图像所行
print(d.shape)
输出：
torch.Size([4, 1, 28, 28])
torch.Size([4, 28, 28])
torch.Size([4, 784])
torch.Size([112, 28])
增加维度 unsqueeze
unsqueeze操作用的非常频繁。
torch.unqueeze(a, pos) 如果pos大于等于0[正的索引]， 则是在pos前插入一个维度
如果pos小于0[负的索引]，则是在pos后插入一个维度。
pos的范围 [-a.dim()-1, a.dim()+1)
unsqueeze并不会增加数据，或者减少数据，只是为数据增加了一个组别。
import torch
a = torch.randn(4, 1, 28, 28) #假设为MINIST数据集
print('a',a.shape)
b = torch.unsqueeze(a, 0) #在0维度前面插入一个维度 没有增加数据
print('b', b.shape)
c = a.unsqueeze(4) #在4维度前面插入一个维度
print('c', c.shape)
d = a.unsqueeze(2) #在第2个维度前面插入一个维度
print('d', d.shape)
e = a.unsqueeze(-1) #在最后-1维度后面插入一个维度
print('e',e.shape)
f = a.unsqueeze(-3) #在-3维度后面之后插入一个维度
print('f',f.shape)
输出：
a torch.Size([4, 1, 28, 28])
b torch.Size([1, 4, 1, 28, 28])
c torch.Size([4, 1, 28, 28, 1])
d torch.Size([4, 1, 1, 28, 28])
e torch.Size([4, 1, 28, 28, 1])
f torch.Size([4, 1, 1, 28, 28])
偏置和图像叠加：
import torch
bias = torch.randn(32)
f = torch.rand(4, 32, 14,14) #bias相当于每个通道上的偏置
# 将bias叠加在f上
b = bias.unsqueeze(0).unsqueeze(2).unsqueeze(3) #[1,32]->[1,32,1]->[1,32,1,1]
print(b.shape)
输出：
torch.Size([1, 32, 1, 1])
维度挤压 squeeze
squeeze(dim) 挤压所有dim上为1的维度。
import torch
bias = torch.randn(32)
f = torch.rand(4, 32, 14,14) #bias相当于每个通道上的偏置
# 将bias叠加在f上
b = bias.unsqueeze(0).unsqueeze(2).unsqueeze(3) #[1,32]->[1,32,1]->[1,32,1,1]
print('b', b.shape)
c = b.squeeze() #挤压掉所有为1的维度
print('c', c.shape)
d = b.squeeze(0) #挤压掉0维数据
print('d', d.shape)
e = b.squeeze(1) #挤压掉第1维数据 如果第1维大小不为1,则挤压失败，返回原来的维度
print('e', e.shape)
f = b.squeeze(-4) #挤压第-4维维度
print('f', f.shape)
输出：
b torch.Size([1, 32, 1, 1])
c torch.Size([32])
d torch.Size([32, 1, 1])
e torch.Size([1, 32, 1, 1])
f torch.Size([32, 1, 1])
维度扩展 Expand/repeat
Expand：只是改变了理解方式，并没有增加数据，参数为扩展到多少维度
repeat：实实在在增加了数据（复制了内存），参数为要拷贝的次数
最终的效果是等效的，Expand只会在有需要的时候复制数据。
expand测试
import torch
bias = torch.randn(32)
f = torch.rand(4, 32, 14,14) #bias相当于每个通道上的偏置
# 将bias叠加在f上
b = bias.unsqueeze(0).unsqueeze(2).unsqueeze(3) #[1,32]->[1,32,1]->[1,32,1,1]
print('b', b.shape)
# c = b.expand(4,10,1,1) #扩展第0个维度 第1个维度不为1，所以该扩展失败（报错），其余维度不变
d = b.expand(4,32,14,14) #扩展所有维度
print(d.shape)
e = b.expand(100,32,1,1)
print(e.shape)
输出:
b torch.Size([1, 32, 1, 1])
torch.Size([4, 32, 14, 14])
torch.Size([100, 32, 1, 1])
repeat测试
import torch
bias = torch.randn(32)
f = torch.rand(4, 32, 14,14) #bias相当于每个通道上的偏置
# 将bias叠加在f上
b = bias.unsqueeze(0).unsqueeze(2).unsqueeze(3) #[1,32]->[1,32,1]->[1,32,1,1]
print('b', b.shape)
c = b.repeat(4,32,14,14) #[1,32,1,1] -> [14,32,14,14] 拷贝
print('after repeat all dim:', b.shape)
d = b.repeat(10,32,1,1) #[1,32,1,1]->[1*10,32*32,1,1]拷贝第一个维度10次，第二个维度拷贝32次， 其余的拷贝一次
print('repeat dim 0,1:', d.shape)
输出：
b torch.Size([1, 32, 1, 1])
after repeat all dim: torch.Size([1, 32, 1, 1])
repeat dim 0,1: torch.Size([10, 1024, 1, 1])
tensor转置
只会在维度为2的tensor上进行转置.t()操作。
import torch
b = torch.randn(3,4)
print('b', b.shape)
c = b.t()
print('b.t()', c.shape)
输出：
b torch.Size([3, 4])
b.t() torch.Size([4, 3])
transpose() 交换两个维度
view()会导致维度顺序关系变模糊，所以需要人为跟踪。view了维度之后，一定要记住view之前维度的先后顺序。
contiguous()将数据重新申请一片连续的内存并将数据复制过来。一般使用transppose(),permute()函数过后需要view()操作，就需要使用contiguous()函数使数据内存连续。
import torch
a = torch.randn(4,3,32,32)
b = a.transpose(1,3).contiguous().view(4,3*32*32).view(4,3,32,32) #数据污染了
c = a.transpose(1,3).contiguous().view(4,3*32*32).view(4,32,32,3).transpose(1,3)
d = a.transpose(1,3).contiguous().view(-1) #使用a.transpose(1,3).view(-1)会报错， 必须要加一个contiguous()函数
permute转置
[b,h,w,c]是numpy图片的格式。需要将[b,c,h,w]转换为[b,h,w,c]才能导出为numpy.
MINIST数据集是numpy格式，那么需要用到torchvision.transforms.Totensor()将维度进行变换，并且转为tensor.
#将tensor图像数据转换为numpy图像数据
#将tensor图像数据转换为numpy图像数据
import torch
a = torch.randn(4,3,32,32)
print(a.shape)
b = a.transpose(1,3).transpose(1,2) #[b,c,h,w]->[b,w,h,c]->[b,h,w,c]
print(b.shape)
c = a.permute(0,2,3,1)
print(c.shape)
输出：
torch.Size([4, 3, 32, 32])
torch.Size([4, 32, 32, 3])
torch.Size([4, 32, 32, 3])
Tensor的广播/自动扩展
Broadcasting：（自动）维度扩展，不需要拷贝数据
Broadcasting自动扩展的步骤：
从最小维度（shape从最右维度）开始匹配，如果匹配维度前面没有维度，则插入一个新的维度（没有增加数据）。(unsqueeze)
然后将扩展的维度变成相同的size。（expand）
[4,32,14,14]与[32,1,1]
第一个匹配的维度是前一个数据的第二维，size为32,对应第二个数据的第零维，则需要在第二个数据前面扩展维一个维度，使之与第一个数据匹配。
#tensor自动扩张
import torch
a = torch.randn(2,3,3)
b = torch.tensor([5.0])
print(a)
print(a+b)
输出：
tensor([[[ 1.3627, -0.3175, 0.9737],
[-1.0720, 0.3555, -1.0382],
[ 0.4370, -1.2669, 1.8456]],
[[-0.2490, 2.1087, -1.2171],
[ 0.1234, -0.7962, -0.0916],
[-0.2550, 0.2806, -1.1539]]])
tensor([[[6.3627, 4.6825, 5.9737],
[3.9280, 5.3555, 3.9618],
[5.4370, 3.7331, 6.8456]],
[[4.7510, 7.1087, 3.7829],
[5.1234, 4.2038, 4.9084],
[4.7450, 5.2806, 3.8461]]])
什么情况下可以使用broadcasting
小维度指定，大维度随意。
1.缺失维度，扩展至同一维度，扩展至统一大小
2.维度不缺失，dim_size =1, 扩展至相同大小
例子：
必须要从最小维度开始匹配：
Tensor的合并与分割
tensor的拼接与拆分
cat操作
torch.cat(Tensors, dim) cat拼接的tensor必须在非cat维度上一致。
#tensor拼接
import torch
a = torch.rand(4,32,8)
b = torch.rand(5,32,8)
c = torch.cat((a,b),dim=0)
print(c.shape)
输出：
torch.Size([9, 32, 8])
stack操作
stack会创建一个新的维度，这个新建的维度的概念取决于具体的场景。并且stack的tensor的维度必须完全一摸一样。
#tensor堆叠
import torch
a = torch.rand(4,32,8)
b = torch.rand(4,32,8)
c = torch.stack((a,b),dim=0)
print(c.shape)
输出:
torch.Size([2, 4, 32, 8])
split操作
torch.split根据指定块的长度拆分。
#tensor拆分
import torch
a = torch.rand(4,3,3)
aa,bb = torch.split(a,[1,3], dim=0)
print(aa.shape)
print(bb.shape)
cc,dd = torch.split(a, 2, dim = 0) #在0维度上按照单元长度为2进行拆分
print(cc.shape)
print(dd.shape)
输出：
torch.Size([1, 3, 3])
torch.Size([3, 3, 3])
torch.Size([2, 3, 3])
torch.Size([2, 3, 3])
chunk操作
torc.chunk根据数量拆分。指定要拆分成多少个块
#tensor拆分
import torch
a = torch.rand(4,3,3)
bb,cc,dd,ee = torch.chunk(a,4,dim=0) #将零维度拆分为4个块
print(bb.shape)
print(cc.shape)
print(dd.shape)
print(ee.shape)
输出：
torch.Size([1, 3, 3])
torch.Size([1, 3, 3])
torch.Size([1, 3, 3])
torch.Size([1, 3, 3])
Tensor的数学运算
加减乘除操作 element-wise
+ - * / 操作：逐元素计算
torch.add
torch.sub
torch.mul
torch.div
矩阵乘法
torch.mm 只适用于2维矩阵的乘法
torch.matmul
@ 等同于torch.matmul 写法更简洁
#tensor矩阵乘法
import torch
a = torch.full((2,2),3.)
b = torch.ones((2,2))
c = a.mm(b) #只适用于2维矩阵的乘法
d = torch.mm(a,b)
e = torch.matmul(a,b) #推荐使用这个方法，更加易懂
f = a@b #@符号更加简洁
print(a)
print(b)
print(c)
print(d)
print(e)
print(f)
输出：
tensor([[3., 3.],
[3., 3.]])
tensor([[1., 1.],
[1., 1.]])
tensor([[6., 6.],
[6., 6.]])
tensor([[6., 6.],
[6., 6.]])
tensor([[6., 6.],
[6., 6.]])
tensor([[6., 6.],
[6., 6.]])
神经网络线性层乘法：
#tensor线性层矩阵乘法
import torch
x = torch.rand(4,784)
w = torch.rand(512, 784)
out = x.matmul(w.t()) #.t()只适合二维的转置，如果是高维的矩阵，则使用transpose进行转置
print(out.shape)
out = x@w.t()
print(out.shape)
输出：
torch.Size([4, 512])
torch.Size([4, 512])
高维的神经网络数据乘法：
不能使用torch.mm，使用torch.matmul，torch.matmul只取最后两维数据进行计算。
#tensor高维矩阵乘法
import torch
x = torch.rand(4,3,28,64)
w = torch.rand(4,3,64,32)
w2 = torch.rand(4,1,64,128)
out = torch.matmul(x,w)
print(out.shape)
out2 = torch.matmul(x,w2) #w2通过广播机制转换为[4,3,64,128]
print(out2.shape)
输出：
torch.Size([4, 3, 28, 32])
torch.Size([4, 3, 28, 128])
幂运算
Tensor每个元素做幂运算/取平方根/平方根的倒数。
** 幂运算
torch.pow 幂运算
torch.sqrt 取平方根
torch.rsqrt取平方根的倒数
#tensor高维矩阵乘法
import torch
a = torch.full((2,2),3)
b = a**2
c = a.pow(2)
print(a)
print(b)
print(c)
d = b.sqrt()
e = b.rsqrt()
print(d)
print(e)
输出：
tensor([[3, 3],
[3, 3]])
tensor([[9, 9],
[9, 9]])
tensor([[9, 9],
[9, 9]])
tensor([[3., 3.],
[3., 3.]])
tensor([[0.3333, 0.3333],
[0.3333, 0.3333]])
exp log
import torch
a = torch.exp(torch.full((2,2),1))
print(a)
print(torch.log(a)) #以e为取log, 此外还有log2(以2为底) log10(以10为底)
输出：
tensor([[2.7183, 2.7183],
[2.7183, 2.7183]])
tensor([[1., 1.],
[1., 1.]])
近似值
torch.floor() tensor数值向下取整
torch.ceil() tensor数值向上取整
torch.round() tensor数值取四舍五入
torch.trunc() tensor数值取整数部分
torch.frac() tensor的小数部分
import torch
a = torch.tensor([3.14, 5.67, 10])
print('*'*10)
print(a.floor())
print('*'*10)
print(a.ceil())
print('*'*10)
print(a.trunc())
print('*'*10)
print(a.frac())
print('*'*10)
print(a.round())
输出：
**********
tensor([ 3., 5., 10.])
**********
tensor([ 4., 6., 10.])
**********
tensor([ 3., 5., 10.])
**********
tensor([0.1400, 0.6700, 0.0000])
**********
tensor([ 3., 6., 10.])
clamp裁剪
clamp函数用于裁剪，比如梯度裁剪。梯度弥散就是梯度接近于0，一般可通过修改网络来解决，梯度爆炸就是梯度非常大，比如100，10^3…
可以通过w.grad.norm(2) 打印梯度的模（l2范数）来查看。一般10左右小于10是合适的。
import torch
grad = torch.rand(2,3)*15
print(grad.median())
print(grad.norm(2))
clip_grad = grad.clamp(10) #将梯度小于10的设置为10
print(clip_grad)
clip_grad = grad.clamp(5,10) #将梯度设置为5-10之间
print(clip_grad)
输出：
tensor(3.1846)
tensor(21.2192)
tensor([[14.6256, 10.0000, 10.8478],
[10.0000, 10.0000, 10.0000]])
tensor([[10.0000, 5.0000, 10.0000],
[ 5.0000, 9.7487, 5.0000]])
Tensor的统计属性
求范数 norm
norm指的是范数，不是normalize；
向量范数和矩阵范数：
norm-p
import torch
a = torch.full([8],1, dtype = torch.float)
b = a.view(2,4)
c = a.view(2,2,2)
print(a.norm(1), b.norm(1), c.norm(1))
print(a.norm(2), b.norm(2), c.norm(2))
print(b.norm(1, dim = 1))
print(c.norm(2, dim = 0))
输出：
tensor(8.) tensor(8.) tensor(8.)
tensor(2.8284) tensor(2.8284) tensor(2.8284)
tensor([4., 4.])
tensor([[1.4142, 1.4142],
[1.4142, 1.4142]])
常见统计属性 mean,sum,min,max,prod
prod 累乘函数
mean,max,min等如果没有指定维度，则会将tensor展平，然后再统计。
import torch
a = torch.arange(8).view(2,4).float()
print(a.min(), a.max())
print(a.sum(), a.mean())
print(a.prod())
print(a.argmax(), a.argmin())
输出：
tensor(0.) tensor(7.)
tensor(28.) tensor(3.5000)
tensor(0.)
tensor(7) tensor(0)
dim指定维度
import torch
t = torch.arange(8).reshape(2,4).float()
print('**Caculate after flatten..')
print(t.max())
print(t.min())
print(t.sum())
print(t.mean())
print(t.prod())
print('**Get the position of the max/min elements on all dim..')
print(t.argmax())
print(t.argmin())
print('**Gaculate on special dim..')
print(t.mean(1))
print(t.max(1))
print(t.min(0))
print(t.sum(0))
print(t.prod(1))
输出：
**Caculate after flatten..
tensor(7.)
tensor(0.)
tensor(28.)
tensor(3.5000)
tensor(0.)
**Get the position of the max/min elements on all dim..
tensor(7)
tensor(0)
**Gaculate on special dim..
tensor([1.5000, 5.5000])
torch.return_types.max(
values=tensor([3., 7.]),
indices=tensor([3, 3]))
torch.return_types.min(
values=tensor([0., 1., 2., 3.]),
indices=tensor([0, 0, 0, 0]))
tensor([ 4., 6., 8., 10.])
tensor([ 0., 840.])
keepdim保持维度
import torch
t = torch.arange(8).reshape(2,4).float()
print('**Gaculate on special dim..')
print(t.max(1, keepdim=True))
print(t.min(0, keepdim=True))
print(t.sum(0, keepdim=True))
输出：
**Gaculate on special dim..
torch.return_types.max(
values=tensor([[3.],
[7.]]),
indices=tensor([[3],
[3]]))
torch.return_types.min(
values=tensor([[0., 1., 2., 3.]]),
indices=tensor([[0, 0, 0, 0]]))
tensor([[ 4., 6., 8., 10.]])
top-k k-th
topk：比max提供了更多的信息
kthvalue：第K小的值
import torch
t = torch.arange(8).reshape(2,4).float() #K大值
t2 = t.topk(3, dim=1)
print(t2)
t3 = t.topk(3, dim=1, largest=False) #K小值
print(t3)
print('*'*20)
t4 = t.kthvalue(2, dim=1)
print(t4)
输出：
torch.return_types.topk(
values=tensor([[3., 2., 1.],
[7., 6., 5.]]),
indices=tensor([[3, 2, 1],
[3, 2, 1]]))
torch.return_types.topk(
values=tensor([[0., 1., 2.],
[4., 5., 6.]]),
indices=tensor([[0, 1, 2],
[0, 1, 2]]))
********************
torch.return_types.kthvalue(
values=tensor([1., 5.]),
indices=tensor([1, 1]))
compare
- torch.eq(a,b) torch.equal(a,b)
import torch
a = torch.arange(8).reshape(2,4).float() #K大值
r = a>0
print(r)
r2 = torch.gt(a,1)
print(r2)
#判断每个元素是否相等
r3 = torch.eq(a,a)
#判断两个Tensor是否每个元素都相等
r4 = torch.equal(a,a)
print(r3)
print(r4)
b = torch.ones(2,4)
r5 = torch.eq(a,b) #bool和0,1进行比较
r6 = torch.equal(a,b)
print(r5)
print(r6)
输出：
tensor([[False, True, True, True],
[ True, True, True, True]])
tensor([[False, False, True, True],
[ True, True, True, True]])
tensor([[True, True, True, True],
[True, True, True, True]])
True
tensor([[False, True, False, False],
[False, False, False, False]])
False
Tensor的高阶操作
where
赋值语句高度并行
import torch
cond = torch.tensor([[0.6,0.7],[0.8,0.4]])
a = torch.ones(2,2)
b = torch.zeros(2,2)
c = torch.where(cond>0.6, a,b)
print(c)
输出：
tensor([[0., 1.],
[1., 0.]])
gather
根据提供的表和索引收集数据
import torch
table = torch.arange(4,8)
index = torch.tensor([0,2,1,0,3,0])
t = torch.gather(table,dim=0,index=index)
print(t)
输出：
tensor([4, 6, 5, 4, 7, 4])
