pytorch基础

持续补充

import torch

1.随机相关

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.查看数据形状

a.type()			输出数据类型

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

a.dim()				输出维度

3.生成矩阵

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.]])

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

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

5.切片

基本操作与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.维度转换

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.如果两个矩阵维度不同的话就在低纬度处增加维度。
		例如：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.torch.mm() 二维矩阵的乘除
						 2.torch.matmul() 多维矩阵的乘除,多维矩阵相乘其实就是矩阵最高的两个维度相乘，其他维度不变
						 	所以说相乘的两个矩阵要符合二维矩阵相乘的条件:前者列数等于后者行数
						 	并且若其余低维不相等，还不符合广播的，则不能相乘
						 3.@ 第2条的简写

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

9.属性统计

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.高阶操作

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