1、Broadcasting(广播)也就是自动实现了若干unsqueeze和expand操作，以使两个Tensor的shape一致，从而完成某些操作（往往是加法）。
2、Broadcasting能够实现自动维度扩展，有点像上节学的expand的功能，但是是自动完成的，而且不需要像repeat那样对数据进行拷贝，可以节省内存。
3、
而两个向量要是broadcast的话，必须满足以下两个条件
- 每个tensor至少是一维的
- 两个tensor的维数从后往前，对应的位置要么是相等的，要么其中一个是1，或者不存在
>>> x=torch.empty(5,7,3) >>> y=torch.empty(5,7,3) # 相同维数的tensor一定是broadcastable的 >>> x=torch.empty((0,)) >>> y=torch.empty(2,2) # 不是broadcastable的，因为每个tensor维数至少要是1 >>> x=torch.empty(5,3,4,1) >>> y=torch.empty( 3,1,1) # 是broadcastable的，因为从后往前看，一定要注意是从后往前看！ # 第一个维度都是1，相等，满足第二个条件 # 第二个维度其中有一个是1，满足第二个条件 # 第三个维度都是3，相等，满足第二个条件 # 第四个维度其中有一个不存在，满足第二个条件 # 但是 >>> x=torch.empty(5,2,4,1) >>> y=torch.empty( 3,1,1) # 不是broadcastable的，因为从后往前看第三个维度是不match的 2!=3，且都不是1torch.cat(tensors,dim=0,out=None)作用：
torch.cat是将两个tensor拼接在一起torch.cat主要有两种用法，一种是按维数0拼接（按行拼接），另一种是按维数1拼接（按列拼接） -
1、在使用torch.cat进行拼接时，除拼接维数dim数值可不同外，其余维数数值需相同
2、两个拼接的tensor需要用[]或者（）包裹起来
3、dim=0表示按行拼接，dim=1表示按列拼接
4、cat还可以把list中的tensor拼接起来ps:二维理解起来比较方便，但是实践中常用到的均是三维起，当维数>2时，dim=0表示以第0维拼接，
对于一个张量的维度，有几个[]就是几维，因此dim=0表示将第一个[]的内容进行拼接，同理dim=ntorch.stack
作用:与torch.cat相同，torch.stack也是用于拼接两个张量，同样有张量列表和维度两个参数区别于torch.cat:
torch.stack()函数要求输入张量的大小完全相同，得到的张量的维度会比输入的张量的大小多1，并且多出的那个维度就是拼接的维度，那个维度的大小就是输入张量的个数。这样讲可能有点难以理解，没关系，我们来看个例子。
使用torch.stack我们发现，返回的tensor在第0维前面增加了一个维度，而这个维度的维数就是拼接的张量的个数。我们也可以增加在其他的维度前。
torch.split
torch.split(tensor,split_size_or_sections,dim=0)
作用：把一个tensor分割成若干个小tensor
torch.split主要是按照长度进行拆分，第一种情况长度一致，另一种长度不一致
方法 说明
add() Tensor中每个元素同加一个标量，或与另一个Tensor逐元素相加
mul() Tensor中每个元素同乘一个标量，或与另一个Tensor逐元素相乘
div() Tensor中每个元素同除一个标量，或与另一个Tensor逐元素相除
fmod()和remainder() Tensor中每个元素与一个标量的除法余数，相当于Python中的%操作
abs() 对Tensor中的每个元素取绝对值，并返回
ceil() 对Tensor中的每个元素向上取整
floor() 对Tensor中的每个元素向下取整
clamp() 对Tensor中的每个元素取上下限
round() 对Tensor中的每个元素取最近的整数
frac() 返回Tensor中每个元素的分数部分
neg() 对Tensor中的每个元素取负
reciprocal() 对Tensor中的每个元素取倒数
log() 返回一个张量，包含Tensor中每个元素的自然对数
pow() 对Tensor中的每个元素同取一个标量幂值，或采用另外一个Tensor的对应元素
取幂，或对标量采用Tensor的每个元素取幂
exp() 返回一个张量，包含Tensor中每个元素的指数
sigmoid() 返回一个张量，包含Tensor中的每个元素的sigmoid值
sign() 返回一个张量，包含Tensor中每个元素的正负值
sqrt() 返回一个张量，包含Tensor中每个元素的平方根
dist() 返回两个Tensor的范数
mean() 返回Tensor中所有元素的均值
norm() 返回Tensor的范数值
prod() 返回Tensor的所有元素之积
sum() 返回Tensor的 所有元素之和
max() 返回Tensor的所有元素的最大值
min() 返回Tensor的所有元素的最小值方法 说明
dot() 两个向量点积
mv() 矩阵与向量相乘
mm() 两个矩阵相乘
addmm() 将两个矩阵进行矩阵乘法操作的结果与另一个矩阵相加
addmv() 将矩阵和向量相乘的结果与另一个向量相加
addr() 将两个向量进行张量积（外积）操作的结果与另一个矩阵相加
bmm() 两个batch内的矩阵进行批矩阵乘法
eig() 计算方阵的特征值和特征向量
ger() 两个向量的张量积
inverse() 对方阵求逆
addbmm() 将两个batch内的矩阵进行批矩阵乘法操作并累加，其结果与另一矩阵相加
baddbmm() 将两个batch内的矩阵进行批矩阵乘法操作，其结果与另一batch内的矩阵相加 属性统计
范数
第一范数
import torch
a = torch.full([8],1)
b = a.view(2,4)
# tensor([[1, 1, 1, 1],
# [1, 1, 1, 1]])
c = a.view(2,2,2)
# tensor([[[1, 1],
# [1, 1]],
#
# [[1, 1],
# [1, 1]]])
a = a.float() # 需要转化为float，否则报错Can only calculate the mean of floating types. Got Long instead
b = b.float()
c = c.float()
# 第一范式
a.norm(1) # tensor(8.)
b.norm(1) # tensor(8.)
c.norm(1) # tensor(8.)
第二范数
a.norm(2) # tensor(2.8284)
b.norm(2) # tensor(2.8284)
c.norm(2) # tensor(2.8284)
# 在第一个维度上，1-范数
b.norm(1,dim=1) # tensor([4., 4.])
# 在第一个维度上，2-范数
b.norm(2,dim=1) # tensor([2., 2.])
c.norm(1,dim=0)
# tensor([[2., 2.],
# [2., 2.]])
c.norm(2,dim=0)
# tensor([[1.4142, 1.4142],
# [1.4142, 1.4142]])
mean、sum、min、max、prod
a = torch.arange(8).view(2,4).float()
# tensor([[0., 1., 2., 3.],
# [4., 5., 6., 7.]])
a.min() # tensor(0.) 最小值
a.max() # tensor(7.) 最大值
a.mean() # tensor(3.5000) 平均值
a.sum() # tensor(28.) 累加
a.prod() # tensor(0.) 累乘
a.argmax() # tensor(7) 最大值的索引，将数据打平之后的索引
a.argmin() # tensor(0) 最小值的索引，将数据打平之后的索引
a = torch.randn(4,10)
a.argmax(dim=1) # tensor([0, 1, 4, 9]) 返回维度的最大数的索引
# 更简单的做法，直接返回最大值和对应的索引
a.max(dim=1)
# torch.return_types.max(
# values=tensor([1.7486, 0.8279, 1.1447, 2.9224]),
# indices=tensor([0, 1, 4, 9]))
topk
a = torch.rand(4,10)
# tensor([[0.1952, 0.0522, 0.0049, 0.5136, 0.8603, 0.8427, 0.8195, 0.9584, 0.2865,
# 0.3642],
# [0.1997, 0.4595, 0.3956, 0.6997, 0.1752, 0.6585, 0.4618, 0.8720, 0.4493,
# 0.8950],
# [0.3413, 0.3944, 0.4641, 0.5972, 0.7680, 0.6328, 0.0565, 0.6384, 0.8459,
# 0.1884],
# [0.8966, 0.7085, 0.9635, 0.8404, 0.3393, 0.1922, 0.2011, 0.9136, 0.9064,
# 0.6741]])
# top3
a.topk(3, dim=1) # 在10这个维度中，获取前三个最大的值，并返回对应的索引
# torch.return_types.topk(
# values=tensor([[0.9584, 0.8603, 0.8427],
# [0.8950, 0.8720, 0.6997],
# [0.8459, 0.7680, 0.6384],
# [0.9635, 0.9136, 0.9064]]),
# indices=tensor([[7, 4, 5],
# [9, 7, 3],
# [8, 4, 7],
# [2, 7, 8]]))
# 最小3个
a.topk(3, dim=1, largest = False)
# 第8小的(相当于第3大)，方法只能算第几小，不能算第几大
a.kthvalue(8,dim=1)
# torch.return_types.kthvalue(
# values=tensor([0.8427, 0.6997, 0.6384, 0.9064]),
# indices=tensor([5, 3, 7, 8]))
逻辑运算
a = torch.rand(2,3)
# tensor([[0.3328, 0.8201, 0.0464],
# [0.6762, 0.1728, 0.4123]])
a>0
# tensor([[True, True, True],
# [True, True, True]])
b = torch.ones(2,3)
torch.eq(a,b)
# tensor([[False, False, False],
# [False, False, False]])
torch.equal(a,b)
# False
高阶操作
1. where 函数
torch.where(condition, x, y)：c o n d i t i o n conditioncondition 是条件，x xx 和 y yy 是同 s h a p e shapeshape 的矩阵，针对 x xx 矩阵中的每个元素，如果满足 c o n d i t i o n conditioncondition 条件就保留元素，不满足 c o n d i t i o n conditioncondition 条件就使用 y yy 矩阵对应位置的元素值进行替换，最后返回结果。
2.gather
使用torch.gather(input,dim,index)对元素实现一个查表映射的操作：
torch.gather(input, dim, index, out=None)
官方给出的解释是这样的: 沿给定轴dim，将输入索引张量index指定位置的值进行聚合。
这个解释很空洞，还不如举几个例子直观。
index的大小和input的大小不一定是一样的，index的大小表示输出的大小。他表示的是你所选择的维度上的操作，对于二维张量来说，如果dim=0，表示在列量的行数据上选择，若dim=1，则在行数据上选择。
比如对于下面的a张量，dim=0表示在[1,3]和[2,4]上选择，dim=1表示在[1,2]和[3,4]上选择。输出的大小和index的大小一致。
379
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
