二、张量的简介与创建

2.1张量的概念

1. 张量的概念：Tensor
   张量是一个多维数组，它是标量、向量、矩阵的高维拓展

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

3. Tensor:PyTorch 0.4.0版开始，Variable并入Tensor
   dtype:张量的数据类型，如torch.FloatTensor,torch.cuda.FloatTensor

   torch.float32 or torch.float 代表32-bit floating point较为重要，在卷积层的权值和图像预处理后，都默认为32-bit floating point
   torch.int64 or torch.int代表64-bit integer(signed)也是较为重要的，图像的标签通常用长整型，在计算交叉熵的损失函数时会用到

   shape:张量的形状，如(64,3,224,224)
   device:张量所在设备，GPU/CPU，是加速的关键
   torch.Tensor
   data,dtype,shape,device这四个与数据相关
   requires_grad,grad,grad_fu,is_leaf这四个与梯度求导相关

2.2张量的创建

2.2.1直接创建

torch.tensor()

功能：从data创建tensor

• data:数据，可以是list,numpy的ndarray
• dtype:数据类型，默认与data的一致，比如输入的data是ndarray，它的数据类型是numpy的64位整型，那tensor也是64位整型
• device:所在设备，cuda/cpu
• requires_grad:是否需要梯度
• pin_memory:是否存于锁页内存，这与转换效率有关，基本行设置为false
  例子：

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

完整代码如下

# ===============lesson 1 ==============
arr = np.ones((3, 3))
print("ndarray 的数据类型是{}".format(arr.dtype))
# t = torch.tensor(arr)
t = torch.tensor(arr, device="cuda")//用gpu会比较慢，因为需要将数据从CPU转到GPU需要耗时
print(t)

显示如下：

ndarray 的数据类型是 float64
tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], device='cuda:0', dtype=torch.float64)//cuda是用GPU,0是GPU的编号

*torch.from_numpy(ndarray)

功能：从numpy创建tensor
注意事项：从torch.form_numpy创建的tensor于原ndarray共享内存，当修改其中一个的数据，另外一个也将会被改动。这里笔者犯了一个错误，就是一开始在修改arr的时候，直接将arr= np.array，这样的话相当于新赋了一个地址给arr，所以t才不会变。因此他们是共享内存的

flag = True
# flag = False
if flag:
    arr = np.array([[1,7,3],[4,5,6]])
    t = torch.from_numpy(arr)
    print(arr)
    print(t)

    # 修改arr
    print("修改arr")
    arr[0,0] = 2
    print(arr)
    print(t)

    # 修改t
    print("修改tensor")
    t[0,0]=9
    print(arr)
    print(t)

显示为

[[1 7 3]
 [4 5 6]]
tensor([[1, 7, 3],
        [4, 5, 6]], dtype=torch.int32)
修改arr
[[2 7 3]
 [4 5 6]]
tensor([[2, 7, 3],
        [4, 5, 6]], dtype=torch.int32)
修改tensor
[[9 7 3]
 [4 5 6]]
tensor([[9, 7, 3],
        [4, 5, 6]], dtype=torch.int32)

Process finished with exit code 0

2.2.2依据数值创建

01torch.zeros()

功能：依size创建全0张量

• size:张量的形状，如(3,3)、(3,244,244)
• out:输出的张量
• layout:内存中布局形式，有strided,sparse_coo等，通常我们直接使用默认的strided即可，是稀疏张量的时候用sparse_coo
• device:所在设备，gpu/cpu
• requires_grad:是否需要梯度
  例子：

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

tips:python中用id()来显示数据在内存中的地址

flag = True
# flag = False
if flag:
    out_t = torch.tensor([1])
    t= torch.zeros([3,3],out=out_t)

    print(t)
    print(out_t)
    print(id(out_t),id(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]])
1672141164992 1672141164992 True

即表示out属性是给一个变量名而已，地址都是一样的

02torch.zeros_like()

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

• input:创建与input同形状的全0张量
• dtype:数据类型
• layout:内存中布局形式

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

03torch.ones()

04torch.ones_like()

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

• size:张量的形状，如(3,3),(3,224,224)
• dtype:数据类型
• layout:内存中布局形式
• device:所在设备，gpu/cpu
• requires_grad:是否需要梯度
  例子

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

05torch.full()

06torch.full_like()

功能：依input形状创建指定数据的张量

• size:张量的形状，如(3,3)
• fill_value:张量的值
  例子

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

flag = True
# flag = False
if flag:

    t= torch.full([3,3],11)

    print(t)

显示内容如下

tensor([[11, 11, 11],
        [11, 11, 11],
        [11, 11, 11]])

07torch.arange()

功能：创建等差的1维张量
注意事项：数值区间维[start,end)这里注意是半闭半开的，也就是end是取不到的

• start:数列的起始值
• end:数列的结束值
• step:数列公差，默认为1

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

flag = True
# flag = False
if flag:
    t= torch.arange(1,11,2)//11是取不到的，半闭半开
    print(t)

tensor([1, 3, 5, 7, 9])//是一维的张量

08torch.linspace()

功能：创建均分的1维张量
注意事项：数值区间为[start,end]//此时是闭合区间

• start:数列起始值
• end:数列结束值
• steps:数列长度

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

flag = True
# flag = False
if flag:
    t= torch.linspace(1,11,4,dtype=torch.int)
    print(t)

tensor([ 1,  4,  7, 11], dtype=torch.int32)

09torch.logspace()

功能：创建对数均分的1维张量
注意事项：长度为steps，底为base

• start:数列起始值
• end:数列结束值
• steps:数列长度
• base:对数函数的底，默认为10

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

10torch.eye()

功能：创建单位对角矩阵（2维张量）
注意事项：默认为方阵

• n:矩阵行数
• m:矩阵列数

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

flag = True
# flag = False
if flag:
    t= torch.eye(4)
    print(t)

tensor([[1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.],
        [0., 0., 0., 1.]])

2.2.3依据概率创建

01torch.normal()

功能：生成正态分布（高斯分布）

• mean:均值
• std:标准差

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

四种模式

mean为标量，std为标量
mean为标量，std为张量
mean为张量，std为标量
mean为张量，std为张量

torch.normal(mean, 
			std, 
			out=None)
			torch.normal(mean, 
			std, 
			size,
			out=None)

02*torch.randn() *

03*torch.randn_like() *

功能：生成标准正态分布

• size : 张量的形状

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

flag = True
# flag = False
if flag:
    t1 = torch.arange(1,5,dtype=torch.float)
    t2 = torch.arange(1,5,dtype=torch.float)

    tt=torch.normal(t1,t2)
    print("mean = {}\nstd = {}".format(t1,t2))
    print(tt)

tt是怎么样生成的呢？是通过mean=1,std=1生成的0.5543的高斯分布的值（正态分布），以此类推

mean = tensor([1., 2., 3., 4.])
std = tensor([1., 2., 3., 4.])
tensor([0.5543, 3.1875, 3.4800, 4.7976])

flag = True
# flag = False
if flag:
    # mean:张量，std:张量
    # t1 = torch.arange(1,5,dtype=torch.float)
    # t2 = torch.arange(1,5,dtype=torch.float)
    # tt = torch.normal(t1, t2)
    # print("mean = {}\nstd = {}".format(t1, t2))
    # print(tt)
    '''
    mean = tensor([1., 2., 3., 4.])
    std = tensor([1., 2., 3., 4.])
    tensor([ 2.8870, -0.8132,  4.5278, -3.5147])
    '''

    # mean:标量，std:标量
    # t1 = 1
    # t2 = 1
    # tt = torch.normal(t1, t2, (4,))# 此时需要加上维数
    # print("mean = {}\nstd = {}".format(t1, t2))
    # print(tt)
    '''        
    mean = 1
    std = 1
    tensor([1.5022, 1.5284, 1.2761, 0.5369])
    '''

    # mean:张量，std:标量
    # t1 = torch.arange(1,5,dtype=torch.float)
    # t2 = 1
    # tt=torch.normal(t1,t2)
    # print("mean = {}\nstd = {}".format(t1,t2))
    # print(tt)
    '''
    mean = tensor([1., 2., 3., 4.])
    std = 1
    tensor([1.0856, 1.3022, 0.3630, 3.4465])
    '''
    # mean:标量，std:张量
    # t1 = 1
    # t2 = torch.arange(1,5,dtype=torch.float)
    # tt=torch.normal(t1,t2)
    # print("mean = {}\nstd = {}".format(t1,t2))
    # print(tt)
    '''
    mean = 1
    std = tensor([1., 2., 3., 4.])
    tensor([1.8799, 2.3412, 5.7135, 8.4491])
    '''

04torch.rand()

05torch.rand_like()

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

06torch.randint ()

07torch.randint_like()

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

• size : 张量的形状

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

08torch.randperm()

功能：生成生成从0到n-1的随机排列

• n : 张量的长度
  经常用来设置乱序的索引

09torch.bernoulli()

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

• input : 概率值

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