pytorch对tensor的一些基本操作(二)

Tensor张量

import torch

1.torch.stack(): 对tensors沿指定维度拼接，但返回的Tensor会多一维

a=torch.rand(2,3)
b=torch.randn(2,3)
d=torch.stack((a,b), dim=0)
print(d)
print(d.size())

tensor([[[ 0.6726,  0.1213,  0.2705],
         [ 0.6798,  0.1086,  0.5244]],

        [[-0.5596,  0.2247, -0.7475],
         [-0.4650, -0.5764,  1.7613]]])
torch.Size([2, 2, 3])

2.torch.sum()，torch.mean()，torch.max() :求和,平均,最值操作

a=torch.tensor([[1.0,2.0,3.0],[4.0,5.0,6.0]])
print(a)
print(torch.sum(a,dim=0))
c=torch.mean(a,0)#只能对浮点数
print(c)
max_value,maxindex=torch.max(a,1)#返回每一行的最大值及其在该行的索引
print(max_value)
print(maxindex)

tensor([[1., 2., 3.],
        [4., 5., 6.]])
tensor([5., 7., 9.])
tensor([2.5000, 3.5000, 4.5000])
tensor([3., 6.])
tensor([2, 2])

3.squeeze，unsqueeze:降维与升维

a=torch.tensor([[1,2,3],[4,5,6]])
print(a)
print(a.size())
a=a.unsqueeze(1)
print(a)
print(a.size())
print("***********")
b=torch.tensor([[1,2,3]])
print(b)
print(b.size())
b=b.unsqueeze(1)
print(b)
print(b.size())

tensor([[1, 2, 3],
        [4, 5, 6]])
torch.Size([2, 3])
tensor([[[1, 2, 3]],

        [[4, 5, 6]]])
torch.Size([2, 1, 3])
***********
tensor([[1, 2, 3]])
torch.Size([1, 3])
tensor([[[1, 2, 3]]])
torch.Size([1, 1, 3])

4.torch.permute()

但没有 torch.permute() 这个调用方式， 只能 Tensor.permute()。 我们可以把这个permute的过程这样理解；把tensor中的各维度上的值和编号对应，那么 对于tensor（0，1，2，3），permute（d0,d1,d2,d2)分别把 0和d0、1和d1、2和d2、3和d3的维度值交换，并且 d0，d1,d2,d3就是0，1，2，3的一个排列； 注：这里的维度值表示的是在该维度上有多少个数据；eg.对于二维的tensor（3，4）表示3行4列； 0表示行，1表示列。

a = torch.rand(2, 3, 4)
print(a.shape)
a = a.permute(2, 1, 0)
print(a.shape)

torch.Size([2, 3, 4])
torch.Size([4, 3, 2])

5.tensor的数值

在获取tensor的数值的时候，当只有一个元素时候使用 tensor.item()，否则使用tensor.tolist()；

在使用这两个方法的时候不需要考虑当前数据是再GPU还是CPU，的问题，而使用numpy()就需要了

a = torch.randn(1)
print(a.item())
b=torch.randn(2,3)
print(b.tolist())

1.733506202697754
[[1.4020272493362427, -0.41212621331214905, 1.1351789236068726], [0.18131841719150543, 1.118831992149353, -0.9648651480674744]]

6.常用的tensor计算torch.gt()，torch.lt()，torch.eq()，torch.ne()

• torch.gt() 大于（大于为true，否则为false）ge()大于等于
• torch.lt() 小于（小于为true，否则为false）le()小于等于
• torch.eq()等于（等于为true，否则为false）
• torch.ne() 非 （等于为false，否则为true）

a=torch.randn(2,3)
print(a)
print(a.gt(0))
print(a.lt(0))
print(a.eq(0))
print(a.ne(0))

tensor([[-1.5922, -2.1408, -1.4729],
        [-0.8615,  0.3474, -0.4214]])
tensor([[False, False, False],
        [False,  True, False]])
tensor([[ True,  True,  True],
        [ True, False,  True]])
tensor([[False, False, False],
        [False, False, False]])
tensor([[True, True, True],
        [True, True, True]])

7.torch.masked_select()，torch.masked_fill()

• torch.masked_select：选择x的对应mask中true对应的下标的值
• torch.masked_fill：将a对应mask为true的位置替换为value。

x = torch.randn(2, 4)
print(x)
mask = x.ge(0.5)#大于等于
print(mask)
print(torch.masked_select(x, mask))
print(x.masked_fill(mask,0.0))

tensor([[ 1.5942, -0.3780, -1.8494, -0.3787],
        [ 0.9498,  0.1370, -0.2406,  1.3839]])
tensor([[ True, False, False, False],
        [ True, False, False,  True]])
tensor([1.5942, 0.9498, 1.3839])
tensor([[ 0.0000, -0.3780, -1.8494, -0.3787],
        [ 0.0000,  0.1370, -0.2406,  0.0000]])

8.cuda和device 指定tensor 用什么计算

device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
a = torch.rand([2,3]).to(device)
print(a)

tensor([[0.0740, 0.3338, 0.8749],
        [0.5854, 0.3424, 0.3774]], device='cuda:0')

9.requires_grad

这里想说的是关于模型的中参数的梯度问题，在网络结构中，经常会让一部分参数不更新，一部分更新，具体做法如下：

需要注意的是我们定义的tensor默认的required_grad=False;但是模型中的参数默认required_grad=True

10.torch.mm,torch.bmm,torch.matmul

• torch.mm

从下面的例子可以看出来就是简单的矩阵相乘。

l=[[1,2,3],[3,3,3]]
l1=[[2,2],[2,2],[1,1]]
a=torch.tensor(l1)
b=torch.tensor(l)
print(a)
print(a.size())
print(b)
print(b.size())
c=torch.mm(a,b)
print(c)
print(c.size())

tensor([[2, 2],
        [2, 2],
        [1, 1]])
torch.Size([3, 2])
tensor([[1, 2, 3],
        [3, 3, 3]])
torch.Size([2, 3])
tensor([[ 8, 10, 12],
        [ 8, 10, 12],
        [ 4,  5,  6]])
torch.Size([3, 3])

• torch.bmm

和mm类似只是变成了多个矩阵相乘，也就是batch-mm

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

tensor([[[2., 3.],
         [1., 2.]],

        [[3., 4.],
         [0., 5.]]])
tensor([[[3.],
         [1.]],

        [[2.],
         [4.]]])
tensor([[[ 9.],
         [ 5.]],

        [[22.],
         [20.]]])

• torch.matmul

l=[[1,9],[2,2]]
l1=[1,3]
a=torch.tensor(l1)
b=torch.tensor(l)
print(a)
print(b)
c=torch.matmul(a,b)
print(c)

tensor([1, 3])
tensor([[1, 9],
        [2, 2]])
tensor([ 7, 15])

• mm只能进行矩阵乘法,也就是输入的两个tensor维度只能是( n × m ) (n\times m)(n×m)和( m × p ) (m\times p)(m×p)
• bmm是两个三维张量相乘, 两个输入tensor维度是( b × n × m ) (b\times n\times m)(b×n×m)和( b × m × p ) (b\times m\times p)(b×m×p), 第一维b代表batch size，输出为( b × n × p ) (b\times n \times p)(b×n×p)
• matmul可以进行张量乘法, 输入可以是高维.