Pytorch张量操作

1.数据类型

如何表示string?

• One-hot         [0,1,0,0,...]
• Embedding    Word2vec，glove

类型推断

#type check
a=torch.randn(2,3)       
print(a.type())                            #torch.FloatTensor
print(type(a))                             #<class 'torch.Tensor'>  这种情况比较少
print(isinstance(a, torch.FloatTensor))    #True

标量

#标量 dimension 0/rank 0（常用于loss）
b=torch.tensor(1.3)
print(b)                 #tensor(1.3000)
print(b.shape)           #torch.Size([])  成员
print(len(b.shape))      #0
print(b.size())          #torch.Size([])  成员函数

张量

#张量 dimension 1（常用于bias）
print(torch.tensor([1.1]))    #tensor([1.1000]) 指定具体数据，可以是N维
print(torch.FloatTensor(1))   #tensor([9.6429e-39]) 指定具体维度，随机初始化
data=np.ones(2)
print(torch.from_numpy(data)) #tensor([1., 1.], dtype=torch.float64) 从numpy引入

c=torch.ones(2)
print(c.shape)                #torch.Size([2])

#张量 dimension 2
d=torch.randn(2,3)
print(d)
#tensor([[-1.8543, -0.7280,  0.6671],
#        [ 1.1492, -0.6379, -0.4835]])
print(d.shape)          #torch.Size([2, 3])
print(d.shape[0])       #2
print(d.size(1))        #3    

#张量 dimension 3
f=torch.rand(1,2,3)
print(f)
#tensor([[[0.3690, 0.5702, 0.2382],
#         [0.3130, 0.5591, 0.3829]]])
print(f.shape)         #torch.Size([1, 2, 3])
print(f[0])            #取第一个维度
#tensor([[0.4535, 0.4307, 0.6469],
#        [0.1591, 0.0778, 0.4489]])
print(f[0][1])         #tensor([0.1591, 0.0778, 0.4489])

四维适合表示图片类型

eg：a=torch.rand(b,c,h,w)表示b张c通道、h*w的图片

a=torch.rand(2,3,28,28)
print(a.numel())       #4704 全部元素个数
print(a.dim())         #4 维度数量 

2.创建Tensor

#方法一：import from numpy
a=np.ones([2,3])
print(torch.from_numpy(a))
#tensor([[1., 1., 1.],
#        [1., 1., 1.]], dtype=torch.float64)

#方法二：import from List
print(torch.tensor([[2.,3.2],[1.,22.3]]))
#tensor([[ 2.0000,  3.2000],
#        [ 1.0000, 22.3000]])

Tip：torch.tensor接受现成的数据

         torch.Tensor/torch.FloatTensor接受shape或者现成的数据

未初始化的方法（作为容器，要用其他类型把数据覆盖掉）：

• torch.empty()
• torch.FlostTensor(d1,d2,d3)
• torch.IntTensor(d1,d2,d3)

#设置默认类型
print(torch.tensor([1.2,3]).type())               #torch.FloatTensor（不设定的话，默认值）
torch.set_default_tensor_type(torch.DoubleTensor)
print(torch.tensor([1.2,3]).type())               #torch.DoubleTensor

随机初始化

#rand [0,1]
a=torch.rand(2,2)
print(a)
print(torch.rand_like(a))         #根据a的形状生成，也可用dtype指定新类型

#randint [min,max)不包含max
print(torch.randint(1,10,[3,3]))  #第1个参数是min，第二个参数是max，第三个参数是shape

正态分布

#正态分布
print(torch.randn(3,3))         #N(0,1)
print(torch.normal(mean=torch.full([10],0),std=torch.arange(1,0,-0.1)))    #normal得到的维度为1
#tensor([ 0.1445, -0.5133, -0.5565,  0.0831,  0.1350,  0.1023, -0.6264, -0.1651, 0.2856,  0.0187])

其他

#ones全1，zeros全0，eye对角，ones_like
print(torch.full([2,3],7))             #第一个参数是shape，第二个参数是value
#tensor([[7., 7., 7.],
#        [7., 7., 7.]])
print(torch.full([], 7))               #tensor(7.) 生成标量

#生成 [0,n-1]的等差数列
print(torch.arange(0,10,2))            #tensor([0, 2, 4, 6, 8])

#[0,10]等间距切割成steps份
print(torch.linspace(0, 10, steps=6))  #tensor([ 0.,  2.,  4.,  6.,  8., 10.])
print(torch.logspace(0, 1, steps=5))   #tensor([ 1.0000,  1.7783,  3.1623,  5.6234, 10.0000])


#randperm
print(torch.randperm(10))             #tensor([8, 5, 2, 4, 7, 1, 3, 9, 6, 0])

a=torch.rand(2, 3) 
idx=torch.randperm(2)
print(idx)                            #tensor([1, 0])
print(a[idx])
#tensor([[0.6159, 0.9362, 0.5502],
#        [0.9774, 0.6772, 0.2909]])

3.索引与切片

#切片与索引
a=torch.rand(4,3,28,28)
print(a[0].shape)               #torch.Size([3, 28, 28])
print(a[0,0].shape)             #torch.Size([28, 28])
print(a[0,0,2,4])               #tensor(0.7309)

print(a[:2,:1].shape)           #torch.Size([2, 1, 28, 28])  等价于a[:2,:1,:,:].shape
print(a[:,:,::2,::2].shape)     #torch.Size([4, 3, 14, 14])

使用特定索引index_select

#select by specific index
print(a.index_select(2, torch.arange(8)).shape)  #torch.Size([4, 3, 8, 28])  第1个参数表示维度，第2个参数表示索引号（Tensor类型）
#...表示任意多的维度
print(a[0,...].shape)           #torch.Size([3, 28, 28])
print(a[:,1,...].shape)         #torch.Size([4, 28, 28]) 

使用掩码索引masked_select

#select by mask
x=torch.randn(3,4)
mask=x.ge(0.5)                  #greater equal大于等于
print(mask)
#tensor([[False,  True, False, False],
#        [ True, False, False,  True],
#        [ True, False,  True, False]])
torch.masked_select(x, mask)    #tensor([1.1361, 0.5963, 0.6286, 0.5664, 0.5152]) 维度为1

take索引（在原来Tensor的shape基础上打平，然后在打平后的Tensor上进行索引）

#select by flatten index
src=torch.tensor([[4, 3, 5],[6, 7, 8]])
print(torch.take(src,torch.tensor([0, 2, 5])))  #tensor([4, 5, 8])

4.维度变换

 reshape/view可以调整Tensor的shape，返回一个新shape的Tensor

a=torch.rand(4,1,28,28)
print(a.view(4,28*28).shape)        #torch.Size([4, 784])
print(a.reshape(4*28,28).shape)     #torch.Size([112, 28])

unsqueeze(index)增加维度

index的范围[-a.dim()-1,a.dim()+1)    eg.a的维度=4，范围是[-5,5)

新增加的这一个维度不会改变数据本身，只是为数据新增加了一个组别，这个组别是什么由我们自己定义。

a=torch.rand(4,1,28,28)
print(a.unsqueeze(0).shape)         #torch.Size([1, 4, 1, 28, 28]

b=torch.tensor([1.2, 2.3])          #torch.Size([2])
print(b.unsqueeze(0))               #tensor([[1.2000, 2.3000]])   torch.Size([2, 1])
print(b.unsqueeze(-1)) 
#tensor([[1.2000],
#        [2.3000]])

x=torch.rand(32)
y=torch.rand(4,32,14,14)
x=x.unsqueeze(1).unsqueeze(2).unsqueeze(0)      #[32]->[32,1]->[32,1,1]->[1,32,1,1]
print(x.shape)                                  #torch.Size([1, 32, 1, 1])) 再进行扩展即可计算x+y 

squeeze(index)删减维度，删除size=1的维度

a=torch.rand(1,32,1,1)
print(a.squeeze().shape)             #torch.Size([32])  不指定维度就挤压全部
print(a.squeeze(0).shape)            #torch.Size([32, 1, 1])
print(a.squeeze(-1).shape)           #torch.Size([1, 32, 1])
print(a.squeeze(1).shape)            #torch.Size([1, 32, 1, 1])  size不等于1，删减不了

expand维度扩展：broadcasting（只是改变了理解方式，并没有增加数据）

某个size=1的维度上扩展size

x=torch.rand(32)
y=torch.rand(4,32,14,14)
x=x.unsqueeze(1).unsqueeze(2).unsqueeze(0)      #[32]->[32,1]->[32,1,1]->[1,32,1,1]
print(x.shape)                                  # torch.Size([1, 32, 1, 1])

print(x.expand(4,32,14,14).shape)               #torch.Size([4, 32, 14, 14])
print(x.expand(-1,32,3,-1).shape)               #torch.Size([1, 32, 3, 1])  -1指该维度不变

print((x.expand(4,32,14,14)+y).shape)           #torch.Size([4, 32, 14, 14])

repeat维度重复：memory copied（增加了数据）

repeat会重新申请内存空间，repeat()参数表示各个维度指定的重复次数。

a=torch.rand(1,32,1,1)
print(a.repeat(4,32,1,1).shape)                 #torch.Size([4, 1024, 1, 1])
print(a.repeat(4,1,1,1).shape)                  #torch.Size([4, 32, 1, 1])

转置操作

.t操作指适用于矩阵

a=torch.rand(3, 4)
print(a.t().shape)                             #torch.Size([4, 3])

transpose维度交换

a=torch.rand(4,3,32,32)
b=a.transpose(1, 3).contiguous().view(4,3*32*32).view(4,32,32,3).transpose(1, 3)               
#[b,c,h,w]->[b,w,h,c]->[b,whc]->[b,w,h,c]->[b,c,h,w]  展开时按原来的顺序展开whc对应32,32,3
print(torch.all(torch.eq(a,b)))                       #tensor(True)

permute

四个维度表示的[batch,channel,h,w] ，如果想把channel放到最后去，形成[batch,h,w,channel]，那么如果使用前面的维度交换，至少要交换两次（先13交换再12交换）。而使用permute可以直接指定维度新的所处位置，更加方便。

b=torch.rand(4,3,28,32)
print(b.transpose(1, 3).shape)                      #torch.Size([4, 32, 28, 3])
print(b.transpose(1, 3).transpose(1, 2).shape)      #torch.Size([4, 28, 32, 3])

print(b.permute(0,2,3,1).shape)                     #torch.Size([4, 28, 32, 3]