张量是一个多维数组，它是标量、向量、矩阵的高维拓展。
Variable是 torch.autograd中的数据类型，主要用于封装 Tensor，进行自动求导。
data : 被包装的Tensor
grad : data的梯度
grad_fn : 创建 Tensor的 Function，是自动求导的关键
requires_grad：指示是否需要梯度
is_ leaf : 指示是否是叶子结点（张量）
Pytorch 0.4.0版开始，Variable并入Tensor。
dtype：张量的数据类型，如torch.FloatTensor，torch.cuda.FloatTensor
shape：张量的形状，如(64，3，224，224)
device：张量所在设备，GPU/CPU，是加速的关键。
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)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 Truetorch.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.]]) 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 : 概率值