持续补充

1
import torch

1.随机相关

1
2
3
4
5
6
7
8
9
a = torch.randn(2,3)		正态分布

b = torch.rand(2,3)			0~1范围内随机

c = torch.rand_like(a)		模仿a的形状生成随机矩阵

d = torch.randint(1,10,[2,3,4])		在1~10内生成形状为（2,3,4）的矩阵

a = a.cuda()				将数据加载到gpu内

2.查看数据形状

1
2
3
4
5
a.type()			输出数据类型

a.size() == a.shape		输出张量形状

a.dim()				输出维度

3.生成矩阵

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
a = torch.full([3,4,5],6)        （3,4,5）形状矩阵，用6填满
tensor([[[6., 6., 6., 6., 6.],
         [6., 6., 6., 6., 6.],
         [6., 6., 6., 6., 6.],
         [6., 6., 6., 6., 6.]],

        [[6., 6., 6., 6., 6.],
         [6., 6., 6., 6., 6.],
         [6., 6., 6., 6., 6.],
         [6., 6., 6., 6., 6.]],

        [[6., 6., 6., 6., 6.],
         [6., 6., 6., 6., 6.],
         [6., 6., 6., 6., 6.],
         [6., 6., 6., 6., 6.]]])

# 小写trnsor是自己传值，大写Tensor是传维度

b = torch.tensor(4)				4为填充数据，0维的常量
c = torch.tensor([4])			4为填充数据，1维的向量
d = torch.tensor([[4]])			4为填充数据，2维的矩阵

e = torch.FloatTensor(2,3)		（2,3）为矩阵形状

f = torch.empty(2,3,4)			原则上生成全为0的(2,3,4)维度的矩阵，事实上是很多很大的值

g = torch.eye(5,5)				对角线为1的矩阵
tensor([[1., 0., 0., 0., 0.],
        [0., 1., 0., 0., 0.],
        [0., 0., 1., 0., 0.],
        [0., 0., 0., 1., 0.],
        [0., 0., 0., 0., 1.]])

1. 

1
2
3
torch.arange(1,10,2)		2为步长

torch.linspace(1,10,5)		5为数据个数

5.切片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
基本操作与numpy切片一样，只不过涉及图像处理后，矩阵维度为四维，刚开始接触不太好理解

a = torch.randn(4,3,28,28)

a.shape
    torch.Size([4, 3, 28, 28])

a[0].shape
    torch.Size([3, 28, 28])

a[0,0].shape
    torch.Size([28, 28])
    
a[0,0,0].shape
    torch.Size([28])

a[:2].shape
    torch.Size([2, 3, 28, 28])

a[:2,2:].shape
    torch.Size([2, 1, 28, 28])

a[:,:,::2,::2].shape
    torch.Size([4, 3, 14, 14])

特殊：
... 代表最大维度
a[...].shape
    torch.Size([4, 3, 28, 28])

a[1,...].shape
    torch.Size([3, 28, 28])

a[:1,...,::2].shape		# 当三个点在中间时，根据左右两边的数来确定...代表的维度
    torch.Size([1, 3, 28, 14])

6.维度转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
a = torch.randn(4,3,28,28)

1.打平
    a.view(4,3*28*28)
    将四维矩阵转化为4行，3*28*28列的二维矩阵，矩阵数据不能丢

2.增1维
    a.unsqueeze(0)	0为插入维度的位置，含义为在0维之前再插入一个维度
                    若写为-1，则在-1维之后再插入一个维度，正负有别
    a的shape变为[1,4,3,28,28]
    
3.降1维
    只能去掉dim为1的维度
    a.squeeze(0)   此维度为1的话可以删去，不然的话无效(不会报错)
    
4.让1维度扩展
    expand:只扩展维度
    a = torch.randn(1,32,1,1)
    a.expand(5,32,5,10)			参数为需要转换的维度

    repeat:会复制数据，不常用
    a.repeat(5,1,5,10)			参数为每个维度复制的次数
        

5.转置
    a只能是二维矩阵
    a.t()

6.拼接:cat(),stack()
    c = torch.randn(4,3,7,5)
    d = torch.randn(4,6,7,5)

    torch.cat([c,d] , dim = 1).shape
        >>>torch.Size([4, 9, 7, 5])
    torch.stack([c,c],dim=1).shape
        #传入参数两者维度需相等，然后在dim参数前创建一个新维度
        >>>torch.Size([4, 2, 3, 7, 5])

7.拆分：按比例split() ， 均分chunk()
    w = torch.randn(4,5,6)
    split(步长/比例列表，dim = ？)
    q1 , e1 = w.split(1,dim=0)
        >>>q1,e1.shape:[2,5,6]
    q2 , e2 = w.split([3,1],dim=0)
        >>>q2.shape:[3,5,6]
            e2.shape:[1,5,6]

    w = torch.randn(4,5,6)
    q1 , e1 , t1 , u1 = w.chunk(4,dim=0)	均分四分
    q1 , e1 = w.chunk(4,dim=0)				均分两份

7.广播法则

1
2
3
4
5
6
7
8
9
特点
    1.只可以将一维数据扩展为多维
    2.如果两个矩阵维度不同的话就在低纬度处增加维度。
        例如：a = torch.randn(2,3,4,5)
              b = torch.randn(3,1,1)
              print((a+b).shape)
              	>>>torch.Size([2, 3, 4, 5])
            扩充过程：[3,1,1]->[1,3,1,1]->[2,3,4,5]
            只可以在前面补充维度，不可在其他位置，若两者高纬度数据不等，则不能广播

8.加减乘除

1
2
3
4
5
6
7
8
9
10
可直接对矩阵进行加减乘除

乘除是对相同位置上的元素进行乘除
如需按照矩阵方法进行运算：1.torch.mm() 二维矩阵的乘除
                         2.torch.matmul() 多维矩阵的乘除,多维矩阵相乘其实就是矩阵最高的两个维度相乘，其他维度不变
                         	所以说相乘的两个矩阵要符合二维矩阵相乘的条件:前者列数等于后者行数
                         	并且若其余低维不相等，还不符合广播的，则不能相乘
                         3.@ 第2条的简写

数据取小数和整数部分：.frac() , .trunc()

null
9.属性统计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
a = torch.randn(2,4)

a.norm(int x)  求范数，x代表求几级范数,也可dim指定维度

下面的函数的返回值都是一维的，不论是否加dim，当加上dim后，还可再加keepdim=True这样可以使返回值的维度与数据集维度相同。
a.min()			返回两个tensor ， 返回最大值和其位置
a.max()		
a.sum()
a.mean()	平均值
a.prod()	累乘
a.topk(int num , dim= , largest = True/False)		返回前num个最大(小)的概率
a.kthvalue(int location , dim=)		返回第k小的概率的值和位置

a.argmax()	求最大值的位置，dim指定维度，不指定的话会将a矩阵打平，求最大值位置
a.argmin()	求最小值的位置

torch.eq(a , b)			返回一个0,1矩阵
torch.equal(a , b)		a和b完全相同时返回True，否则返回False。

10.高阶操作

1
2
3
4
5
6
7
8
9
torch.where(condition , x , y) 返回值为tensor:
    condition , x , y维度相同，且condition为0,1矩阵
    如果condition内位置上为1，则取x内的值，否则取y内的值，然后组成一个新tensor返回

torch.gather(input , dim , index , out=None):
    input:可以理解为标签
    dim：维度
    index：标签的坐标，然后以此返回个新的tensor
    out=None