Tensor定义
1.张量 ：对于标量，矩阵，向量更加泛化的表述。可以说矩阵就是2阶的张量，张量可以表示数据的任意维度
以下是创建一些张量代码实例
import torch
#传数据(FlotTensor类型)
a = torch.Tensor( [ [1,2],[3,4] ] )
#基础构造函数
a = torch.Tensor(2,3)
#几种特殊
b = torch.zeros(3,5)
b = torch.ones(2,2)
b = torch.eye(3,3)
c = torch.zeros_like(a)
c = torch.ones_like(a)
#.........随机
a = torch.rand(2,2)
#........正态
a = torch.normal(mean = 0.0, std = torch.rand(2,3)) #mean为均值， std为标准差
a = torch.normal(mean = torch.rand(2,5),std = torch.rand(2,5) )
#..............均匀分布 (FlotTensor类型)
a = torch.Tensor(1,3).uniform_(0,1)
#........序列 (LongTensor类型)
a = torch.arange(0,10,2) #步长为2，最后结尾值不包含在序列中
a = torch.linspace(1,10, 3) #拿到等间隔的3个数字，结尾值包含10
#........随机排列(LongTensor类型)
a = torch.randperm(15) #0-14,数字随机排列
print(a)
print(a.type())
Tensor的三个属性
每个Tensor都有torch.dtype, torch.device, torch.layout三种属性。
torch.dtype :数据类型
torch.device ：标识创建Tensor对象之后所存储的设备名称，有CPU/GPU（cuda）
torch.layout ：表示内存布局对象，有稠密和稀疏之分。上面代码块都是稠密的方式。非零个数越少，数据越稀疏。
稀疏张量只会记录非零元素的坐标和值，这样会节省资源
torch.sparse_coo_tensor（）：稀疏张量定义
以下是关于Tensor属性的代码实例
import torch
dev = torch.device("cpu")
#dev = torch.device("cuda")
a = torch.tensor([2,2], dtype = torch.float32, device=dev)
#定义稀疏张量
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(b)
Tensor的运算
加法：c = a +b
c = torch.add(a, b)
a.add(b)
a.add_(b) [注，最后一种和上面三种机制不一样，它不仅把结果计算出来还会修改a的值，把结果赋予a。运算函数中带下划线的都类似]
减法：c = a-b c = torch.sub(a,b) a.sub(b) a.sub_(b)
乘法，哈达玛积（矩阵对应元素相乘）：
c = a*b c = torch.mul(a,b) a.mul(b) a.mul_(b)
除法：
c = a / b c = torch.div(a, b) a.div(b) a.div_(b)
二维矩阵乘法运算有 torch.mm() 、 torch.matmul() 、 @,以下有四种方式实现
a = torch.ones(2,3) b = torch.ones(3,2)
print( torch.mm(a,b) )
print( torch.matmul(a,b) )
print( a@b )
print( a.mm(b) )
print( a.matmul(b) )
对于高维的Tensor（dim>2）,定义矩阵乘法仅在最后的两个维度上，前面的维度必须保持一致,如下a, b 所定义那样，且运算操作只有torch.matmul（）
a = torch.ones(1, 2, 3, 4)
b = torch.ones(1, 2, 4, 3)
print( a.matmul(b) )
print( torch.matmul(a, b) )
幂运算：
print( torch.pow(a, 2) ) print( a.pow(2) ) print( a**2 )
print( a.pow_(2) ) #注意这里会修改a的值
e^n 有如下表示
print（ torch.exp(n) ） b = n.exp_()[这里会把结果给n]
开方运算
print( a.sqrt() ) print( a.sqrt_() )
对数运算
print( torch.log2(a) )
print( torch.log10(a) )
print( torch.log(a) ) print( torch.log_(a) ) [以e为底]
取整取余运算
print( torch.floor(a) ) # 向下取整数
print( torch.ceil(a) ) # 向上取整数
print( torch.round(a) ) # 四舍五入 >=0.5向上取， <0.5向下取
print( torch.trunc(a) ) # 剪裁，只取整数部分
print( torch.frac(a) ) # 只取小数部分
print(a % 2) # 取余
Tensor的比较运算,
(1-6机制一样，都是返回一个Tensor，里面有Ture or False)
1. torch.eq( input, other, out=None ) #按成员进行等式操作，相同返回Ture
2. torch.ge( input, other, out=None ) #input >= other
3. torch.gt( input, other, out=None ) #input > other
4. torch.le( input, other, out=None ) #input =< other
5. torch.lt( input, other, out=None ) #input < other
6. torch.ne( input, other, out=None ) #input != other
7. torch.equal( Tensor1, Tensor2 ) #若两者有相同的size 和 elements，则为Ture
Tensor的排序及索引
torch.sort( input, dim=None, descending = False, out = None ) #对目标input进行排序
a = torch.tensor( [1, 4, 4, 3, 5] )
print( torch.sort(a) )
**运行结果如下：**
torch.return_types.sort(
values=tensor([1, 3, 4, 4, 5]), 结果
indices=tensor([0, 3, 1, 2, 4]))， 对应数值的索引值
a = torch.tensor( [[1, 4, 4, 3, 5],
[3, 4, 2, 1, 8]] )
print( torch.sort(a, dim=0, descending= True) ) # 2这个维度进行降序排列
**运行结果如下：**
values=tensor([[3, 4, 4, 3, 8],
[1, 4, 2, 1, 5]]),
indices=tensor([[1, 0, 0, 0, 1],
[0, 1, 1, 1, 0]]))
Tensor取前K大/小值及其索引
torch.topk( input, k, dim = None, largest = True, sorted = True, out = None )#沿着指定维度返回最大/最小K个数值及其索引值
a = torch.tensor( [[1, 4, 2, 3, 5],
[9, 5, 3, 1, 8]] )
print(torch.topk( a, k=2, dim=1 )) #沿着5这个维度取2个最大值并排序
**运行结果如下**
torch.return_types.topk(
values=tensor([[5, 4],
[9, 8]]),
indices=tensor([[4, 1],
[0, 4]]))
a = torch.tensor( [[1, 4, 2, 3, 5],
[9, 5, 3, 1, 8]] )
print(torch.topk( a, k=1, dim=0, largest=False )) #沿着2这个维度取一个最小值
**运行结果如下**
torch.return_types.topk(
values=tensor([[1, 4, 2, 1, 5]]),
indices=tensor([[0, 0, 0, 1, 0]]))
torch.kthvalue( input, k, dim=None, out = None ) #沿着指定维度返回第K个最小值及其索引值
a = torch.tensor( [[1, 4, 2, 3, 5],
[9, 5, 3, 1, 8]] )
print( torch.kthvalue(a, k = 2, dim=1) ) #沿着5这个维度取第2个最小值
**运行结果如下：**
torch.return_types.kthvalue(
values=tensor([2, 3]), #第一行第二个最小值为2，第二行第二个最小值为3
indices=tensor([2, 2]))
判定当前Tensor的每个元素是否是 有界，无界，返回一个带true or false 的tensor
torch.isfinite( tensor ) #有界
torch.isinf( tensor ) #无界
torch.isnan( tensor ) #空
