[pytorch]常用函数（自用）

一、公共部分

1、torch.linespace

返回一维张量，在start和end之间（包括start也包括end）的均匀间隔的steps个点，长度为steps。

print(torch.linspace(1,10,3))  #输出tensor([ 1.0000,  5.5000, 10.0000])
print(torch.linspace(-10,10,10))  #tensor([-10.0000,  -7.7778,  -5.5556,  -3.3333,  -1.1111,   1.1111,   3.3333, 5.5556,   7.7778,  10.0000])

2、torch.from_array(ndarray)->Tensor

返回的张量和ndarray共享一片存储区域，修改一个会导致另一个的修改。返回的张量不能改变大小

a=np.array([[1,2,3],[4,5,6]])
b=torch.from_numpy(a)
print(b)#输出tensor([[1, 2, 3],
        #[4, 5, 6]], dtype=torch.int32)
b[0][0]=11
print(a)#输出[[11  2  3] #[ 4  5  6]]

3、torch.numel(input)->int

返回tensor中元素的总个数

a=torch.rand(1,2,3,4)
print(torch.numel(a))#输出24

4、torch.logspace(start,end,steps,out=None)

生成10的start次方和10的end次方的steps个数据点

print(torch.logspace(-10,10,10))#输出tensor([1.0000e-10, 1.6681e-08, 2.7826e-06, 4.6416e-04, 7.7426e-02, 1.2915e+01,
        #2.1544e+03, 3.5938e+05, 5.9948e+07, 1.0000e+10])

5、torch.rand(*size)

生成均值为0，方差为1的高斯分布数据

print(torch.randn((2,3)))

6、torch.randn(*size)

生成均值为0，方差为1的高斯分布数据

print(torch.randn((2,3)))

7、torch.arange(start,end,step=1,out=None)

返回一维张量，在[start,end)之间

torch.range(start,end,step=1,out=None)没什么区别，只不过数据包含end

print(torch.arange(1,89,9))#输出tensor([ 1, 10, 19, 28, 37, 46, 55, 64, 73, 82])

二、索引 切片 连接 换位

2.1 torch.cat(tensors,dim=0,out=None)

第⼀个参数tensors是你想要连接的若⼲个张量，按你所传⼊的顺序进⾏连接，注意每⼀个张量需要形状相同，或者更准确的说，进⾏⾏连接的张量要求列数相同，进⾏列连接的张量要求⾏数相同

第⼆个参数dim表⽰维度，dim=0则表⽰按⾏连接，dim=1表⽰按列连接

a=torch.tensor([[1,2,3,4],[1,2,3,4]])
b=torch.tensor([[1,2,3,4,5],[1,2,3,4,5]])
print(torch.cat((a,b),1))

#输出结果为：

tensor(\[1, 2, 3, 4, 1, 2, 3, 4, 5,

1, 2, 3, 4, 1, 2, 3, 4, 5])

2.2 torch.chunk(tensor,chunks,dim=0)

torch.cat()函数是把各个tensor连接起来，这⾥的torch.chunk（）的作⽤是把⼀个tensor均匀分割成若⼲个⼩tensor

源码定义:torch.chunk(intput,chunks,dim=0)

第⼀个参数input是你想要分割的tensor

第⼆个参数chunks是你想均匀分割的份数，如果该tensor在你要进⾏分割的维度上的size不能被chunks整除，则最后⼀份会略⼩（也可能为空）

第三个参数表⽰分割维度，dim=0按⾏分割，dim=1表⽰按列分割

该函数返回由⼩tensor组成的list

c=torch.tensor([[1,4,7,9,11],[2,5,8,9,13]])
print(torch.chunk(c,3,1))

#输出结果为：

(tensor(\[1, 4,

2, 5]), tensor(\[7, 9,

8, 9]), tensor(\[11,

13]))

2.3 torch.gather(input,dim,index,out=None)

灵活的选取index指定的位置的值进行聚合

注意：

1.index必须是一个张量，不能是普通数组

2.index的形状和input的形状可以不相同

3.index的值作为位置的索引

4.选取值的规则如下：

outijk = tensorindex\[ijk]jk # dim=0

outijk = tensoriindex\[ijk]k # dim=1

outijk = tensorijindex\[ijk] # dim=3

torch.set_printoptions(precision=2)
a=torch.rand(2,3)
aa=torch.gather(a,1,index=torch.LongTensor([[0,1,2],[2,1,1]]))
print("a=",a)
print("aa=",aa)

每个位置的输出结果是：

0,0\] \[0,1\] \[0,2

1,2\] \[1,1\] \[1,1

注：输出的形状和index一致

说明：如果还存在歧义请参考链接：https://www.cnblogs.com/yanghailin/p/18007025

2.4 torch.index_select(input, dim, index)

torch.set_printoptions(precision=2)
# 选取第0行和第3行
a=torch.rand(4,6)
aa=torch.index_select(a,dim=0,index=torch.LongTensor([0,3]))
print('a=',a)
print('aa=',aa)
# 选取第1列和第5列
aaa=torch.index_select(a,dim=1,index=torch.LongTensor([1,5]))
print('aaa=',aaa)
# 选取a的第0行第3行、第1列和第5列,没有先后顺序
aaaa=torch.index_select(aa,dim=1,index=torch.LongTensor([1,5]))
print('aaaa=',aaaa)

2.5 torch.masked_select(input,mask)

a=torch.rand(2,3)
mask1=torch.BoolTensor([[1,0,1],[0,1,0]])
mask2=torch.ByteTensor([[True,False,True],[False,True,False]])
mask3=torch.BoolTensor([[True,False,True],[False,True,False]])
#[[True,False,True],[False,True,False]]
aa=torch.masked_select(a,mask3)
print('a=',a)
print('aa=',aa)

2.6 torch.nonzero(input)

返回非0元素的位置索引

如果输入是n维，那么输出的tensor形状是z*n的，z是输入中所有非0元素的总个数

a=torch.tensor([[[1,0,3],[0,0,9]],[[1,2,0],[0,9,0]]])
aa=torch.nonzero(a)
print('a=',a)
print('aa=',aa)

2.7 torch.split(tensor,split_size,dim)

split_size是切分成的单个块的大小，和chunk不同的是chunk指定的是分块的个数的数量，相同点是它们返回的都是元组，两个效果类似

a=torch.rand(2,3)
aa=torch.split(a,2,dim=1)
print('a=',a)
print('aa=',aa)

2.8 torch.squeeze(input,dim=None)

将形状中为1的维度去除，比如输入的形状是（A1 BC D1 E）那么输出的形状是（AB CD E）

就指定维度，也只对1的形状有效，如果指定的维度长度不为1，则无效，原样输出

a=torch.rand(2,3,1)
aa=torch.squeeze(a)
print('a=',a.size())
print('aa=',aa.size())
aaa=torch.squeeze(a,dim=1)
print('aaa=',aaa.size())

注意：

虽然squeeze前后squeeze后的维度不一致，但是数据量（数据元素的个数）是一致的，并且它们共享一片存储区域，当修改其中一个值时，另一个也会跟着修改。

2.9 torch.stack(sequence,dim=0)-堆叠函数

将序列中包含的张量按照指定维度连接，所有张量的形状应该相同，否则会报错。增加新维度，不是在原有基础上叠加

如两个(2,3)进行stack得到的不会是(4,3)，而是(2,2,3)

a=torch.rand(2,3)
b=torch.rand(2,3)
ab=torch.stack((a,b),dim=0)
print('a=',a)
print('b=',b)
print('ab_size=',ab.size())
print('ab=',ab)

2.10 torch.transpose(input,dim0,dim1)-转置函数

1）交换维度

a=torch.rand(2,3,4)
print('a_size:',a.size())
aa=torch.transpose(a,2,1)
print('aa_size:',aa.size())

2. 共享内存

2.11 torch.unbind(tensor,dim)-解除维度

(2,3,4)->(1,3,4)+(1,3,4)的元组dim=0时

(2,3,4)->(2,1,4)+(2,14)+(2,1,4)的元组dim=1时

a=torch.rand(2,3,4)
aa=torch.unbind(a,1)
print(aa)
print(aa[1].size())

返回的是元组

2.12 torch.unsqueeze(tensor,dim)

1）squeeze的反操作，在dim指定的位置增加一个长度为1的维度（ab cd）->(a 1b c*d)若dim=1

2）共享内存

a=torch.rand(2,3,4)
aa=torch.unsqueeze(a,2)
print(aa.size())