一文理解pytorch张量概念和tensor的三种创建方式！

1、张量是什么？

张量是一个多维数组，它是标量、向量、矩阵的高维拓展。

1.1 Variable

Variable是 torch.autograd中的数据类型，主要用于封装 Tensor，进行自动求导。
data : 被包装的Tensor
grad : data的梯度
grad_fn : 创建 Tensor的 Function，是自动求导的关键
requires_grad：指示是否需要梯度
is_ leaf : 指示是否是叶子结点（张量）

1.2 Tensor

Pytorch 0.4.0版开始，Variable并入Tensor。

dtype：张量的数据类型，如torch.FloatTensor，torch.cuda.FloatTensor
shape：张量的形状，如(64，3，224，224)
device：张量所在设备，GPU/CPU，是加速的关键。

2、张量的创建

2.1 直接创建

torch.tensor(data, dtype=None, device=None, requires_grad=False, pin_memory=False)

功能：从data创建tensor
• data: 数据, 可以是list, numpy
• dtype : 数据类型，默认与data的一致
• device : 所在设备，cuda/cpu
• requires_grad：是否需要梯度
• pin_memory：是否存于锁页内存

torch.from_numpy(ndarray)

功能：从numpy创建tensor
注意事项：从torch.from_numpy创建的tensor于原ndarray共享内存，当修改其中一个的数据，另外一个也将会被改动。

>>> import torch
>>> import numpy as np

#================直接创建==========================
# 通过torch.tensor()创建张量
# data可以是list或者numpy的ndarray
>>> arr = np.ones((3,3))
>>> print("ndarray的数据类型:",arr.dtype)
>>> t = torch.tensor(arr,device="cpu")
>>> print(t)
ndarray的数据类型: float64
tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], dtype=torch.float64)
    
# 通过torch.from_numpy()创建张量
>>> arr = np.array([[1,2,3],[4,5,6]])
>>> t = torch.from_numpy(arr)
>>> print("numpy array:\n",arr)
>>> print("tensor:\n",t)    
numpy array:
 [[1 2 3]
 [4 5 6]]
tensor:
 tensor([[1, 2, 3],
        [4, 5, 6]], dtype=torch.int32)
        
>>> print("\n修改arr")
>>> arr[0,0] = 0
>>> print("numpy array:\n",arr)
>>> print("tensor:\n",t)
修改arr
numpy array:
 [[0 2 3]
 [4 5 6]]
tensor:
 tensor([[0, 2, 3],
        [4, 5, 6]], dtype=torch.int32)

2.2 依据数值创建

torch.zeros(*size,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)

功能：依size创建全0张量
• size: 张量的形状，如(3, 3)、 (3, 224,224)
• out : 输出的张量
• layout : 内存中布局形式, 有strided，sparse_coo等
• device : 所在设备，gpu/cpu
• requires_grad：是否需要梯度

>>> out_t = torch.tensor([1])
>>> t = torch.zeros((3,3),out=out_t)
>>> print(t,"\n",out_t)
>>> print(id(t),id(out_t),id(t)==id(out_t))

tensor([[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]]) 
 tensor([[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]])
2511606349000 2511606349000 True

torch.zeros_like(input,dtype=None,layout=None,device=None,requires_grad=False)

功能：依input形状创建全0张量
• intput: 创建与input同形状的全0张量
• dtype : 数据类型
• layout : 内存中布局形式
• device : 所在设备，gpu/cpu
• requires_grad：是否需要梯度

>>> t1 = torch.zeros((2,2))
>>> torch.zeros_like(t1)
tensor([[0., 0.],
        [0., 0.]])

torch.ones(*size,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)

功能：依size创建全1张量

>>> torch.full((3,3),10)
tensor([[10., 10., 10.],
        [10., 10., 10.],
        [10., 10., 10.]])

torch.ones_like(input,dtype=None,layout=None,device=None,requires_grad=False)

功能：依input形状创建全1张量

torch.full(size,fill_value,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)

功能：依据size，创建全为为fill_value的张量

torch.full_like(input, fill_value,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False,
memory_format=torch.preserve_format)

功能：依input形状创建全为fill_value的张量

torch.arange(start=0,end,step=1,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)

功能：创建等差的1维张量
注意事项：数值区间为[start, end)
• start: 数列起始值
• end : 数列“结束值”
• step: 数列公差，默认为1

>>> torch.arange(2,10,2)
tensor([2, 4, 6, 8])

torch.linspace(start,end,steps=100,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)

功能：创建均分的1维张量
注意事项：数值区间为[start, end]
• start: 数列起始值
• end : 数列结束值
• steps: 数列长度

>>> torch.linspace(2,10,10)
tensor([ 2.0000,  2.8889,  3.7778,  4.6667,  5.5556,  6.4444,  7.3333,  8.2222,  9.1111, 10.0000])

torch.logspace(start,end,steps=100,base=10.0,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)

功能：创建对数均分的1维张量
注意事项：长度为steps, 底为base
• start: 数列起始值
• end : 数列结束值
• steps: 数列长度
• base : 对数函数的底，默认为10

>>> torch.logspace(0,2,10)
tensor([  1.0000,   1.6681,   2.7826,   4.6416,   7.7426,  12.9155,  21.5443, 35.9381,  59.9484, 100.0000])

torch.eye(n,m=None,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)

功能：创建单位对角矩阵（2维张量）
注意事项：默认为方阵
• n: 矩阵行数
• m : 矩阵列数

>>> torch.eye(3)
tensor([[1., 0., 0.],
        [0., 1., 0.],
        [0., 0., 1.]])
>>> torch.eye(3,4)
tensor([[1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.]])     

2.3 依概率分布创建张量

torch.normal(mean, std, *, generator=None, out=None)

功能：生成正态分布（高斯分布）
• mean : 均值
• std : 标准差
四种模式：
mean为标量， std为标量
mean为标量， std为张量
mean为张量， std为标量
mean为张量， std为张量

# mean:张量 std:张量
>>> mean = torch.arange(1,5,dtype=torch.float)
>>> std = torch.arange(1,5,dtype=torch.float)
>>> t_normal = torch.normal(mean,std)
>>> print(t_normal)
tensor([ 1.0155, -1.4016,  4.7298,  7.2105])
# 均值、标准差都为标量时，需要设置size
# 此时只有一个分布
>>> t_normal = torch.normal(0.,1.,size=(4,))
>>> print(t_normal
tensor([-0.4018, -0.8195,  0.7582,  0.1841])
>>> t_normal = torch.normal(mean,1)
>>> print(t_normal)  
tensor([1.3022, 2.8148, 3.1201, 1.5378])
>>> t_normal = torch.normal(1,std)
>>> print(t_normal)
tensor([ 0.0816,  0.0299, -1.2149,  1.5250])

torch.randn(*size,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)

功能：依size生成标准正态度分布。

randn_like(input, dtype=None, layout=None, device=None,requires_grad=False,memory_format=torch.preserve_format)

功能：依input形状生成标准正态度分布。

torch.rand(*size,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)

功能：在区间[0, 1)上，生成均匀分布

randn_like(input, dtype=None, layout=None, device=None,requires_grad=False,memory_format=torch.preserve_format)

功能：依input形状在区间[0, 1)上，生成均匀分布

torch.randint(low=0,high,size,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)

功能：区间[low, high)生成整数均匀分布

randint_like(input, low=0, high, dtype=None,layout=torch.strided, device=None,
requires_grad=False,memory_format=torch.preserve_format)

功能：依input形状在区间[low, high)生成整数均匀分布

torch.randperm(n,out=None,dtype=torch.int64,layout=torch.strided,device=None,requires_grad=False)

功能：生成0到n-1的随机排列
n : 张量的长度

torch.bernoulli(input,*,generator=None,out=None)

功能：以input为概率，生成伯努力分布
（0-1分布，两点分布）
input : 概率值