二、张量的简介与创建

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)

最新文章

  1. javascript事件监听与事件委托
  2. POJ 3176 简单DP
  3. 转载：第六弹！全球首个微信小程序（应用号）开发教程！通宵吐血赶稿！
  4. oracle客户端精简绿色版-环境变量配置
  5. 超图(hypergraph)
  6. 【HTML5】websocket 初识
  7. cron服务 ubuntu
  8. Notice
  9. Python学习6.1_函数参数及参数传递
  10. google自定义站内搜索
  11. (SQL SERVER) (ORACLE) (ACCESS)(POSTGRE SQL)四种数据库操作C#代码
  12. DOMContentLoaded和window.onload
  13. PhotoShop纸张大小
  14. poj 3628 Bookshelf 2 基本01背包
  15. error LNK2001: unresolved external symbol __beginthreadex
  16. Coursera课程 Programming Languages, Part B 总结
  17. Caused by:org.hibernate.MappingNotFoundException:resouce:com/you/model/Monkey.hbm.xml not found
  18. NodeJS定时任务
  19. C++ 配置文件类的封装
  20. react中constructor()和super()的具体含义以及如何使用

热门文章

  1. 【noi 2.6_162】Post Office（DP）
  2. hdu1313 Round and Round We Go (大数乘法)
  3. 洛谷 P6225 [eJOI2019]异或橙子 (树状数组)
  4. Codeforces Round #666 (Div. 2) C. Multiples of Length (构造,贪心)
  5. 错误记录：MQJE001: 完成代码为 '2'，原因为 '2035'。
  6. ARM汇编指令-STMFD/LDMFD
  7. OpenCV+Ubuntu+缺少Python.h
  8. ASP.Net MVP Framework had been dead !
  9. 使用 Promise 实现请求自动重试
  10. node mailer & email bot