pytorch（02）tensor的概念以及创建

二、张量的简介与创建

2.1张量的概念

张量的概念：Tensor

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

Variable是torch.autograd(torch.autograd.Variable)中的数据类型，主要用于封装Tensor

进行自动求导

data：被包装的Tensor

grad：data的梯度

grad_fn：创建Tensor的Function，是自动求导的关键

requires_grad：指示是否需要梯度

is_leaf：指示是否是叶子节点（张量）
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)

02torch.randn()

03torch.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)