pytorch基础知识Tensor算术运算

1、Tensor的基本概念

标量是零维的张量，向量是一维的张量，矩阵是二维的张量

2、Tensor的创建

import torch

"""常见的几个tensor创建"""
a = torch.Tensor([[1,2],[3,4]]) #2行2列的
print(a, a.type())  
print(torch.ones(2,3)) #2行3列全为1的
print(torch.eye(2,3))  #2行3列对角线是1,其余是0
print(torch.zeros(2,3)) #2行3列全为0
print(torch.zeros_like(a)) #2行2列全为0,与a结构一致


"""生成随机的tensor"""
b = torch.rand(2,2)
print(b, b.type())
"""生成正态分布tensor"""
c = torch.normal(mean=0.0, std=torch.rand(5))
print(c, c.type())

d = torch.normal(mean=torch.rand(5), std=torch.rand(5))
print(d, d.type())

"""生成均匀分布的tensor"""
e = torch.Tensor(2,2).uniform_(-1,1)
print(e, e.type())

"""生成序列"""
f = torch.arange(0, 10, 1)
print(f, f.type())

g = torch.linspace(2, 10, 4) #拿到等间隔的4个数字
print(g, g.type())

3、Tensor的属性

torch.dtype

torch.device 代表Tensor创建之后所存储的设备

torch.layout 表示Tensor内存布局的对象（稠密、稀疏张量）

3.1 定义稀疏的张量

torch.sparse_coo_tensor coo元素表示非零元素的坐标形式

import torch

dev = torch.device('cpu')
# dev = torch.device('cuda')

# i非0元素坐标，v非0元素值
i = torch.tensor([[0, 1, 2], [0, 1, 2]])
v = torch.tensor([1, 2, 3])
# 稀疏的张量
a = torch.sparse_coo_tensor(i, v, (4,4), dtype=torch.float32, device=dev)

# 将稀疏的张量转化为稠密的张量
b = a.to_dense()  

print(a)
print("------------------------------------------------")
print(b)


#  打印结果
tensor(indices=tensor([[0, 1, 2],
                       [0, 1, 2]]),
       values=tensor([1., 2., 3.]),
       size=(4, 4), nnz=3, layout=torch.sparse_coo)
------------------------------------------------
tensor([[1., 0., 0., 0.],
        [0., 2., 0., 0.],
        [0., 0., 3., 0.],
        [0., 0., 0., 0.]])

4、Tensor算术运算

4.1 加法

a + b
torch.add(a, b)
a.add(b)
a.add_(b) #会将结果赋值给a

4.2 减法

a - b
torch.sub(a, b)
a.sub(b)
a.sub_(b) #会将结果赋值给a

4.3 乘法

# 哈达玛积，对应元素相乘
a * b
torch.mul(a, b)
a.mul(b)
a.mul_(b) #会将结果赋值给a

4.4 除法

a / b
torch.div(a, b)
a.div(b)
a.div_(b) #会将结果赋值给a

4.5 矩阵运算

a = torch.ones(2,1)
b = torch.ones(1,2)
torch.mm(a, b)
torch.matmul(a, b)
a @ b
a.mm(b)
a.matmul(b)

对于高维度的Tensor（dim>2），定义其矩阵乘法仅在最后的两个维度上，要求前面的维度必须保持一致，运算操作只有torch.matmul()

a = torch.ones(1, 2, 3, 4)
b = torch.ones(1, 2, 4, 3)
print(a.matmul(b))

4.6 Tensor幂运算

torch.pow(a, 2)
a.pow(2)
a**2
a.pow_(2)

torch.exp(a) #e的n次方
a.exp_()

4.7 Tensor开平方运算

a.sqrt()
a.sqrt_()

4.8 Tensor对数运算

torch.log(a) #底数是e
torch.log_(a)
torch.log2()
torch.log10()

4.9 pytorch in-place概念，即 “就地操作”，不允许使用临时变量，也称为原位操作

比如以下运算：

x = x + y

sub_、add_、div_、mul_等

4.10 Tensor的广播机制张量参数可以自动扩展为相同大小

广播机制需要满足两个条件：

1、每个张量至少有一个维度

2、满足右对齐，a+b ,即

a = torch.rand(2,3)
b = torch.rand(3)
print(a+b)  #可以相加，从右向左,b的维度3，那么a的维度要么是3，要么是1

a = torch.rand(2,1)
b = torch.rand(3)
print(a+b)  #可以相加


a = torch.rand(2,4)
b = torch.rand(3)
print(a+b) #从右向左,b的维度3与a的维度4无法对齐,报错

4.11 Tensor的取余数、取整数

a = torch.rand(2,2)
a = a * 10
print(torch.floor(a)) #向上取整
print(torch.ceil(a)) #向下取整
print(torch.round(a)) #四舍五入
print(torch.trunc(a)) #取整数
print(torch.frac(a)) #取小数
print(a % 2) #取余数

4.12 Tensor的比较运算、排序

"""比较"""
a = torch.rand(2, 3)
b = torch.rand(2, 3)
print(torch.eq(a, b)) 
print(torch.equal(a, b)) #比较shape与元素是否都相同
print(torch.gt(a, b))
print(torch.ge(a, b))
print(torch.le(a, b))
print(torch.lt(a, b))
print(torch.ne(a, b))

"""排序"""
a = torch.rand([[1,2,2,5], [2,4,1,3]])
print(torch.sort(a, dim=0, descending=True))  #对第0维排序，降序
print(torch.topk(a, k=2, dim=1)) #返回指定维度上的前k个最大值及其索引
print(torch.kthvalue(a, k=2, dim=0)) # 返回指定维度上的第K个最小值及其索引

print(torch.isfinite(a)) #判断是否有界
print(torch.isfinite(a/2)) 
print(torch.isinf(a/0)) #判断是否无界
print(torch.isnan(a)) #是否None