文章目录
张量的广播(broadcast)特性
相同形状的张量计算
“same shapes are always broadcastable”,相同形状数组总是可以进行广播计算。这里简单强调一下,虽然我们往往觉得不同形状之间的张量计算才是应用到广播特性,但其实相同形状的张量计算,尽管是对应位置元素进行计算,但本质上也是应用到了广播特性。
import torch
t1 = torch.arange(3) # tensor([0, 1, 2])
t2 = torch.arange(2,5) # tensor([2, 3, 4])
# 对应位置元素依次相加
t1 + t2 # tensor([2, 4, 6])
标量和任意形状的张量
标量可以和任意形状的张量进行计算,计算过程就是标量和张量的每一个元素进行计算。
import torch
t1 = torch.arange(3) # tensor([0, 1, 2])
# 1是标量,可以看成是零维
t1 + 1 # tensor([1, 2, 3])
t1 + torch.tensor(1) # tensor([1, 2, 3])
相同维度、不同形状的张量之间计算
t2的形状是(1, 4),和t1的形状(3, 4)在第一个分量上取值不同,但该分量上t2取值为1,因此可以广播,也就可以进行计算。若该分量上t2取值不为1,则不可进行广播
t1 = torch.zeros(3, 4)
t1.shape # torch.Size([3, 4])
t2 = torch.ones(1, 4)
t2.shape # torch.Size([1, 4])
(t1 + t2).shape # torch.Size([3, 4])
t3的形状是(3, 1),和t1的形状(3, 4)在第二个分量上取值不同,但该分量上t3取值为1,因此可以广播,也就可以进行计算。若该分量上t3取值不为1,则不可进行广播
t1 = torch.zeros((3, 4))
t1.shape # torch.Size([3, 4])
t3 = torch.ones(3, 1)
t3.shape # torch.Size([3, 1])
(t1 + t3).shape # torch.Size([3, 4])
t4的形状是(3, 1),而t5的形状是(1, 3),二者的形状在两个份量上均不相同,但都有存在1的情况,因此也是可以广播的
t4 = torch.arange(3).reshape(3, 1)
print(t4.shape) # torch.Size([3, 1])
t5 = torch.arange(3).reshape(1, 3)
print(t5.shape) # torch.Size([1, 3])
(t4 + t5).shape # torch.Size([3, 3])
不同维度的张量计算过程中广播
对于不同维度的张量,我们首先可以将低维的张量升维,然后依据相同维度不同形状的张量广播规则进行广播。
t6 = torch.arange(6).reshape(3, 2)
print(t6.shape) # torch.Size([3, 2])
t7 = torch.arange(7,9)
print(t7.shape) # torch.Size([2])
(t6 + t7).shape # torch.Size([3, 2])
逐点运算(Pointwise Ops)
逐点运算(Pointwise Ops):指的是针对Tensor中每个元素执行的相同运算操作;
加减乘除
函数 | 描述 |
---|---|
torch.add(t1,t2 ) | t1、t2两个张量逐个元素相加,等效于t1+t2 |
torch.subtract(t1,t2) | t1、t2两个张量逐个元素相减,等效于t1-t2 |
torch.multiply(t1,t2) | t1、t2两个张量逐个元素相乘,等效于t1*t2 |
torch.divide(t1,t2) | t1、t2两个张量逐个元素相除,等效于t1/t2 |
t1 = torch.tensor([1, 2]) # tensor([1, 2])
t2 = torch.tensor([3, 4]) # tensor([3, 4])
torch.add(t1, t2) # tensor([4, 6])
t1 + t2 # tensor([4, 6])
Tensor数值调整函数
函数 | 描述 |
---|---|
torch.abs(t) | 返回绝对值 |
torch.ceil(t) | 向上取整 |
torch.floor(t) | 向下取整 |
torch.round(t) | 四舍五入取整 |
torch.neg(t) | 返回相反的数 |
torch.manual_seed(123)
t = torch.randn(5) # tensor([-0.1115, 0.1204, -0.3696, -0.2404, -1.1969])
torch.abs(t) # tensor([0.1115, 0.1204, 0.3696, 0.2404, 1.1969])
注:虽然此类型函数是数值调整函数,但并不会对原对象进行调整,而是输出新的结果。
而若要对原对象本身进行修改,则可考虑使用方法_()
的表达形式,对对象本身进行修改。此时方法就是上述同名函数。
torch.manual_seed(123)
t = torch.randn(5) # tensor([-0.1115, 0.1204, -0.3696, -0.2404, -1.1969])
t.abs_() # tensor([0.1115, 0.1204, 0.3696, 0.2404, 1.1969])
t.exp_() # tensor([1.1179, 1.1279, 1.4472, 1.2718, 3.3099])
Tensor常用科学计算
tensor的大多数科学计算只能作用于tensor对象
数学运算函数 | 数学公式 | 描述 |
---|---|---|
幂运算 | ||
torch.exp(t) | $ y_{i} = e^{x_{i}} $ | 返回以e为底、t中元素为幂的张量 |
torch.expm1(t) | $ y_{i} = e^{x_{i}} $ - 1 | 对张量中的所有元素计算exp(x) - 1 |
torch.exp2(t) | $ y_{i} = 2^{x_{i}} $ | 逐个元素计算2的t次方。 |
torch.pow(t,n) | $\text{out}_i = x_i ^ \text{exponent} $ | 返回t的n次幂 |
torch.sqrt(t) | $ \text{out}{i} = \sqrt{\text{input}{i}} $ | 返回t的平方根 |
torch.square(t) | $ \text{out}_i = x_i ^ \text{2} $ | 返回输入的元素平方。 |
对数运算 | ||
torch.log10(t) | $ y_{i} = \log_{10} (x_{i}) $ | 返回以10为底的t的对数 |
torch.log(t) | $ y_{i} = \log_{e} (x_{i}) $ | 返回以e为底的t的对数 |
torch.log2(t) | $ y_{i} = \log_{2} (x_{i}) $ | 返回以2为底的t的对数 |
torch.log1p(t) | $ y_i = \log_{e} (x_i $ + 1) | 返回一个加自然对数的输入数组。 |
torch.pow(torch.tensor(2), 2) #tensor(4)
t = torch.arange(1, 4).float()
t.dtype # torch.float32
torch.exp(t) # tensor([ 2.7183, 7.3891, 20.0855])
torch.exp(torch.log(t)) # tensor([1., 2., 3.])
规约运算
规约运算指的是针对某张量进行某种总结,最后得出一个具体总结值的函数。此类函数主要包含了数据科学领域内的诸多统计分析函数,如均值、极值、方差、中位数函数等等。
函数 | 描述 |
---|---|
torch.mean(t) | 返回张量均值 |
torch.var(t) | 返回张量方差 |
torch.std(t) | 返回张量标准差 |
torch.var_mean(t) | 返回张量方差和均值 |
torch.std_mean(t) | 返回张量标准差和均值 |
torch.max(t) | 返回张量最大值 |
torch.argmax(t) | 返回张量最大值索引 |
torch.min(t) | 返回张量最小值 |
torch.argmin(t) | 返回张量最小值索引 |
torch.median(t) | 返回张量中位数 |
torch.sum(t) | 返回张量求和结果 |
torch.logsumexp(t) | 返回张量各元素求和结果,适用于数据量较小的情况 |
torch.prod(t) | 返回张量累乘结果 |
torch.dist(t1, t2) | 计算两个张量的闵式距离,可使用不同范式 |
torch.topk(t) | 返回t中最大的k个值对应的指标 |
# 生成浮点型张量
t = torch.arange(10).float()
# 计算均值
torch.mean(t) # tensor(4.5000)
# 计算标准差、均值
torch.std_mean(t) # (tensor(3.0277), tensor(4.5000))
# 计算最大值
torch.max(t) # tensor(9.)
# 返回最大值的索引
torch.argmax(t) # tensor(9)
# 求和
torch.sum(t) # tensor(45.)
dist函数可计算闵式距离(闵可夫斯基距离),通过输入不同的p值,可以计算多种类型的距离,如欧式距离、街道距离等。
t1 = torch.tensor([1.0, 2])
t2 = torch.tensor([3.0, 4])
torch.dist(t1, t2, 2) # 计算欧式距离
torch.dist(t1, t2, 1) # 计算街道距离
由于规约运算是一个序列返回一个结果,因此若是针对高维张量,则可指定某维度进行计算。
# 按照第一个维度求和(每次计算三个)、按列求和
t2 = torch.arange(12).float().reshape(3, 4)
torch.sum(t2, dim = 0) # tensor([12., 15., 18., 21.])
# 按照第二个维度求和(每次计算四个)、按行求和
torch.sum(t2, dim = 1) # tensor([ 6., 22., 38.])
比较运算
比较运算是一类较为简单的运算类型,和Python原生的布尔运算类似,常用于不同张量之间的逻辑运算,最终返回逻辑运算结果(逻辑类型张量)。
函数 | 描述 |
---|---|
torch.eq(t1, t2) | 比较t1、t2各元素是否相等,等效== |
torch.equal(t1, t2) | 判断两个张量是否是相同的张量 |
torch.gt(t1, t2) | 比较t1各元素是否大于t2各元素,等效> |
torch.lt(t1, t2) | 比较t1各元素是否小于t2各元素,等效< |
torch.ge(t1, t2) | 比较t1各元素是否大于或等于t2各元素,等效>= |
torch.le(t1, t2) | 比较t1各元素是否小于等于t2各元素,等效<= |
torch.ne(t1, t2) | 比较t1、t2各元素是否不相同,等效!= |
t1 = torch.tensor([1.0, 3, 4])
t2 = torch.tensor([1.0, 2, 5])
t1 == t2 # tensor([ True, False, False])
# 判断t1、t2是否是相同的张量
torch.equal(t1, t2) # False
torch.eq(t1, t2) # tensor([ True, False, False])
t1 > t2 # tensor([False, True, False])