pytorch tensor创建和矩阵op

pytorch数学运算与统计属性入门（非常易懂） - The-Chosen-One - 博客园这里有很全的说明

类别	OP	参数	语义	实例
创建tensor	torch.Tensor	torch.Tensor(dim0, dim1,..,dimn)	创建维度为(dim0, dim1...dimn)的float32 tensor	torch.Tensor(1, 2) 结果tensor([[-3.4168e+18,  4.5701e-41]])
		troch.Tensor(list)	以list为值，创建float32 tensor	torch.Tensor([1, 2]) 结果tensor([1., 2.])
		torch.Tensor(np.array)	以np.array为值创建float32 tensor	torch.Tensor(np.array([1,2])) 结果tensor([1., 2.])
	torch.tensor	torch.tensor(list)	以list为值，创建tensor，不会强制转为float	torch.tensor([1, 2])结果是tensor([1, 2]) torch.tensor([1.1, 2])结果是tensor([1.1000, 2.0000])
		torch.tensor(np.array)	以np.array为值创建tensor	torch.tensor(np.array([1, 2]))结果是tensor([1, 2]) orch.tensor(np.array([1.1, 2]))结果是tensor([1.1000, 2.0000])
	torch.as_tensor	torch.tensor(list)	以list为值，创建tensor，不强制转为float	torch.as_tensor([1, 2])结果是tensor([1, 2])
		torch.as_tensor(np.array)	以np.array为值创建tensor	a = np.array([1, 2]) b = torch.as_tensor(a) b结果是tensor([1, 2]) 修改a或者b，另一个也会相应的变化，因为内存是共享的
	torch.from_numpy	torch.from_numpy(np.array)	以np.array为值创建tensor	a = np.array([1, 2]) b = torch.from_numpy(a) b结果是tensor([1, 2]) 修改a或者b，另一个也会相应的变化，因为内存是共享的
	torch.ones	torch.ones(*sizes)	创建以sizes为维度，全部为1的tensor	torch.ones(2)结果是tensor([1, 1])
	torch.zeros	torch.zeros(*sizes)	创建以sizes为维度，全部为0的tensor	torch.zeros(2)结果是tensor([0, 0])
	torch.eye	torch.zeros(*sizes)	对角线为1，其他为0的Tensor，只能是2维的	sizes可以是两个数，也可以是一个数，最合理的方式是一个数
	arange	torch.arange(s,e,step)	创建s到e，步长为step的一维Tensor 数值范围是[s,e)，tensor中的每个值于s的差值都能整除step	torch.arange(0,8,3)结果是tensor([0, 3, 6])
	linspace	torch.linspace(s,e,num)	创建s到e，等分成num份的tensor	torch.linspace(0,8,5) 结果是tensor([0., 2., 4., 6., 8.])
	torch.rand	torch.rand(*sizes)	创建范围在[0,1)的均匀分布的tensor	torch.rand(2,2)
	torch.randn	torch.randn(*sizes)	创建标准正态分布的tensor	torch.randn(2,2) 结果是tensor([[-0.5523,  0.3408],                        [ 2.5288,  1.0266]])
	torch.normal	torch.normal(mean,std)	创建正态分布的	最好别用
	torch.randperm	torch.randperm(m)	0到m-1的随机排列	torch.randperm(5) 结果是tensor([4, 1, 0, 2, 3])，这个可以再XLNet里用
tensor操作	torch.cat	torch.cat(tensors:tuple(Tensor), dim)	按某一维度拼接，其他维度都必须一样	dim参数是哪个维度，哪个维度就会扩展
	torch.stack	torch.stack(tensors, dim=0)	将tensor叠起来，会扩充维度，dim可以在[0, tensor.size()]，每一个tensor都必须是同形状的	a = torch.randn(2,2) b = torch.randn(2,2) d2 = torch.stack((a, b), dim=2) dim的取值是[0,1,2]
	torch.transpose	torch.transpose(x, dim0,dim1)	对每一个维度执行output[i][j]=intput[j][i] 做转置，只能对2个维度做转置	a=torch.randn(2,3,4) b=a.transpose(0,2) #和 b=torch.transpose(a, 0, 2)等价 结果a[i][j][k] == b[k][j][i] a和b是共享内存的，该别一个，另一个也会改变结果
	Tensor.permute	Tensor.permute(dim_id0, dim_id1,...)	可以同时对任意维度做转置，transpose是permute的子功能	a = torch.randn(2,3,4) b = a.permute(2,0,1) 则a[i][j][k] == b[k][i][j] a和b是共享内存的，该别一个，另一个也会改变结果
	troch.contiguous	Tensor.contiguous()	narrow(), view(), expand() and transpose()之后的只是产生了一个视图，执行contiguous之后，会copy出一个新的Tensor
	torch.where	torch.where(cond, a, b)	一般a和b同形状	a = toch.rand(2,2) b = torch.zeros(2,2) c = torch.where(a>0, a, b) 结果c得到的tensor是a中负数置零的结果 #where函数相比for循环来说可以实现GPUU高度并行进行，可以提高数数据处理的速度
	torch.squeeze	torch.squeeze(input, dim=None)	将维度为1的维度去掉	a = torch.randn(1,2,1,3) print(a.size()) # torch.Size([1, 2, 1, 3]) b = a.squeeze() # torch.squeeze(a) print(b.size()) # torch.Size([2, 3])
	torch.unsqueeze	torch.unsqueeze(input, dim)	扩充维度	a = torch.randn(2,3) print(a.size()) # torch.Size([2, 3]) b = a.unsqueeze(0) # torch.unsqueeze(a, 0) print(b.size()) # torch.Size([1, 2, 3])
	torch.gather	torch.gather(input, dim, index)	在维度dim上按index取值，index可以比input小，最终的tensor和index同形状 out[i][j][k] = intput[index[i][j][k]][j][k] #dim=0 out[i][j][k] = intput[i][index[i][j][k]][k] #dim=1 out[i][j][k] = intput[i][j][index[i][j][k]] #dim=2	#gather函数-查表操作，可以在GPU上实现，从而提高数据的处理速度，在前沿的一些数据查询和加速方面比较常用
	torch.split	torch.split(input, size, dim=0)	在dim维度上按size进行分割，最后一个可能小于size大小，产出是一个view。size可以是一个list	a = torch.randn(5,5) b = torch.split(a, 2) 分割出三个tensor，size分别是torch.Size([2, 5])， torch.Size([2, 5]) ，torch.Size([1, 5])
	torch.chunk	torch.split(input, size, dim=0)	和split类似，但是size只能是一个int	chunk和split的区别
	torch.expand	Tensor.expand(*sizes)	在维度为1的维度上复制数据，产生视图	a = torch.rand(1, 2) b = a.expand(2, 2) print(b) 结果是tensor([[0.5009, 0.7291], [0.5009, 0.7291]])
	Tensor.view	Torch.view(*sizes)	产生视图	is_contiguous直观的解释是Tensor底层一维数组元素的存储顺序与Tensor按行优先一维展开的元素顺序是否一致。 a = torch.randn(2,4) b = a.view(4,2).contiguous()则a,b依然是共享内存的，因为内存是连续的
	torch.narrow	torch.narrow(input, dim, st, length)	裁剪出一个子tensor视图	a=troch.randn(4,4) b=torch.narrow(a, 0, 2, 2) c=a[2:4, :] b和c是相同的矩阵
矩阵运算	troch.matmul	torch.matmul(a, b)	a，b都是一维则结果是scalar; a，b都是二维则是矩阵相乘；和torch.mm类似 a，b都是三维，及时第0维不同，有一个是1，也可以运算，会扩充；则和torch.bmm类似 a，b维度不同，	a = torch.randn(5,3,1,4,2) b = torch.randn(5,2,4) c = torch.matmul(a, b)  print (c.size()) torch.Size([5, 3, 5, 4, 4])
	torch.mm	torch.matmul(a, b)	二维矩阵相乘
	torch.bmm	torch.matmul(a, b)	三维矩阵相乘，0维是batch a (b×n×m)， b(b×m×p)，则结果是(b×n×p)
	torch.clamp	torch.clamp(input, min, max)	将input中超出[min,max]的元素设置为min或max	梯度裁剪比较常用
算数运算	torch.add/sub/mul/div	torch.add/sub/mul/div(a, b)	相应元素做加减乘除，在维度不一样的时候会做expand，（其实容易使开发人员出bug）	a = torch.randn(4,1,4) b = torch.randn(2,4) c = torch.div(a, b)  print(c.size()) #  torch.Size([4, 2, 4])
	torch.log/log10/log2/exp/pow		对数，指数，幂函数	torch.log以e为底
	torch.acos/cosh/cos/asin/sinh/ sin/atan/tanh/tan/atan2		三角函数
	torch.abs	torch.abs(input)	绝对值
	Tensor.floor/ceil/trunc/frac/round		向下取整/向上取整/整数部分/小数部分/四舍五入
	troch.norm		向量长度，平方和开根号
	torch.mean/sum/std		平均数/求和/标准差	需要特别说明的是，a.std()得到的是无偏标准差(即分母是n-1)
	troch.prod	troch.prod(intput, dim=None)	乘积运算，	元素相乘
比较运算	torch.gt/lt/eq/equal		gt/lt/eq是大于/小于/等于，分别是返回一个tensor，单独判断每一个元素；equal判断两个tensor是否一模一样（形状不同一定是false）；	a = torch.tensor([1,2,3]) b = torch.tensor([0,3,2]) torch.gt(a, 0) # torch.tensor([True, True, True]) torch.gt(a,b) # tensor([ True, False, True])
	>/</==/!=/>=/<=		大于/小于/等于/不等于/大于等于/小于等于	都是element-wise的比较，产生一个tensor
统计运算	min/max/argmax/argmin