文档章节

Pytorch学习笔记(二)——Tensor

o
 osc_y8yehimr
发布于 2019/03/20 16:24
字数 2189
阅读 10
收藏 0

精选30+云产品,助力企业轻松上云!>>>

一、对Tensor的操作

从接口的角度讲,对Tensor的操作可以分为两类:

(1)torch.function (2)tensor.function

比如torch.sum(a, b)实际上和a.sum(b)功能等价。

从存储的角度讲,对Tensor的操作也可以分为两类:

(1)不修改自身数据,如a.add(b),加法结果返回一个新的tensor;

(2)修改自身数据,如a.add_(b),加法结果仍存在a中,a被改变。

函数名以_结尾的称为inplace方式。

二、Tensor的创建

常见的新建tensor的方法:

Tensor(*sizes) 基础构造函数,不分配空间,未初始化

ones(*sizes) 全1的tensor

zeros(*sizes) 全0的tensor

eye(*sizes) 对角线为1,其余为0,不要求行列数相同

arange(s, e, step) 从s到e,步长为step

linspace(s, e, steps) 从s到e,均匀切分成steps份

rand/randn(*sizes) 均匀/标准分布

normal(mean, std)/uniform(from, to) 正态分布/均匀分布

randperm(m) 随机排列

 

range(start, end, step),返回一个list对象也就是range.object,起始值为start,终止值为end,但不含终止值,步长为step。只能创建int型list。range的step不能是浮点型。

arange(start, end, step),与range()类似,也不含终止值。但是返回一个array对象。需要导入numpy模块(import numpy as np或者from numpy import*),arange可以使用浮点型数据。

 

Tensor既可以接收一个list,也可以根据指定形状新建tensor,还可以传入其他的tensor。

tensor.size()等价于tensor.shape()。

a = t.Tensor(2, 3)
b = t.Tensor([[1, 2, 3], [4, 5, 6]])
print(b.tolist()) # 把tensor转为list
print(b.size()) # 形状
print(b.numel()) # 元素总个数
c = t.Tensor(b.size())

通过tensor.view方法可以调整tensor的形状,但要保证调整前后元素总数一致。view不会更改自身数据,但是新的tensor与原tensor共享内存。也就是说更改其中一个,另一个也会跟着改变。

如果要添加或减少某一维度,就需要通过squeeze和unsqueeze函数。

a = t.arange(0, 6)
print(a.view(2, 3))
b = a.view(-1, 3) # 当某一维为-1时,系统自动计算大小
print(b)
print(b.unsqueeze(1)) # 在第一维度上增加一维
print(b.unsqueeze(-2)) # 在倒数第二维上增加一维

运行结果:

tensor([[0, 1, 2],
        [3, 4, 5]])
tensor([[0, 1, 2],
        [3, 4, 5]])
tensor([[[0, 1, 2]],

        [[3, 4, 5]]])
tensor([[[0, 1, 2]],

        [[3, 4, 5]]])
a = t.arange(0, 6)
print(a.view(2, 3))
b = a.view(-1, 3) # 当某一维为-1时,系统自动计算大小
c = b.view(1, 1, 1, 2, 3)
print(c.squeeze(0).size())
print(c.squeeze().size()) # 将所有维度为1的压缩

运行结果:

tensor([[0, 1, 2],
        [3, 4, 5]])
torch.Size([1, 1, 2, 3])
torch.Size([2, 3])

resize也可以用来调整tensor的大小。如果新尺寸超过了原始尺寸,那么会自动分配新的内存空间;而如果新尺寸小于原尺寸,则之前的数据依旧会保留。

a = t.arange(0, 6)
b = a.view(-1, 3) # 当某一维为-1时,系统自动计算大小
a[1] = 100 # 由于a与b共享内存,所以a改变时b也会改变
b.resize_(1, 3)
print(b)
print(b.resize_(3, 3)) # 之前的数据并没有因为上一步的resize操作丢失

运行结果:

tensor([[  0, 100,   2]])
tensor([[                  0,                 100,                   2],
        [                  3,                   4,                   5],
        [  31244186271350784, 3775491366621020160, 5936959698761888869]])

Tensor支持与numpy.ndarray相似的索引操作。索引结果与原tensor共享内存。注意以下两种索引的区别:

a = t.randn(3, 4)
print(a[0 : 1, : 2].size())
print(a[0, : 2].size())

运行结果:

torch.Size([1, 2])
torch.Size([2])

选择产生的结果与原tensor不共享内存空间。

torch.FloatTensor(2,3) 构建一个2*3 Float类型的张量

torch.DoubleTensor(2,3) 构建一个2*3 Double类型的张量

torch.ByteTensor(2,3) 构建一个2*3 Byte类型的张量

torch.CharTensor(2,3) 构建一个2*3 Char类型的张量

torch.ShortTensor(2,3) 构建一个2*3 Short类型的张量

torch.IntTensor(2,3) 构建一个2*3 Int类型的张量

torch.LongTensor(2,3) 构建一个2*3 Long类型的张量

torch.Tensor是默认的tensor类型(torch.FlaotTensor)的简称。

三、tensor数据类型转换

torch.long() 将tensor转换为long类型

torch.half() 将tensor转换为半精度浮点类型

torch.int() 将该tensor转换为int类型

torch.double() 将该tensor转换为double类型

torch.float() 将该tensor转换为float类型

torch.char() 将该tensor转换为char类型

torch.byte() 将该tensor转换为byte类型

torch.short() 将该tensor转换为short类型

几种数据类型转换的方式如下:

a = t.Tensor(2, 3)
b = a.float()
c = a.type_as(b)
d = a.new(2, 3)

四、选择

 

gather操作

对于一个二维tensor,输出的每个元素如下:

out[i][j] = input[index[i][j]][j] # dim = 0
out[i][j] = input[i][index[i][j]] # dim = 1
a = t.arange(0, 16).view(4, 4)
index = t.LongTensor([[0, 1, 2, 3]])
print(a.gather(0, index)) # 提取对角线元素
index = t.LongTensor([[3, 2, 1, 0]]).t() # 针对2D tensor转置
print(a.gather(1, index)) # 提取反对角线元素
index = t.LongTensor([[3, 2, 1, 0]])
print(a.gather(0, index)) # 提取反对角线元素

运行结果:

tensor([[ 0,  5, 10, 15]])
tensor([[ 3],
        [ 6],
        [ 9],
        [12]])
tensor([[12,  9,  6,  3]])

gather的逆操作是scatter_,gather是把数据从input中按照index取出,而scatter_是把取出的数据再放回去。

高级索引

x[[1, 2], [1, 2], [2, 0]] # x[1, 1, 2]和x[2, 2, 0]
x[[2, 1, 0], [0], [1]] # x[2, 0, 1], x[1, 0, 1], x[0, 0, 1]
x[[0, 2], ...] # x[0]和x[2]

五、逐元素操作

 

其中clamp实现的功能如下:

 

六、归并操作

使输出形状小于输入形状,并沿着某一维度进行指定操作。比如加法sum,既可以计算整个tensor的和,也可以计算tensor中每一行或者每一列的和。常用的归并操作如下:

 

以上函数几乎都有一个dim参数,类似于numpy的axis,用于指定这些操作在哪个维度上执行。简单来说,假设输入形状为(m, n, k):

如果dim=0,则输出形状为(1, n, k)或(n, k);

如果dim=1,则输出形状为(m, 1, k)或(m, k);

如果dim=2,则输出形状为(m, n, 1)或(m, n)。

size中是否有“1”,取决于参数keepdim,如果keepdim=True会保留维度1。其中keepdim默认值为False。

七、比较操作

 

t.max(tensor) 返回tensor中最大的一个数

t.max(tensor, dim) 指定维度上的最大的数,返回tensor和下标

t.max(tensor1, tensor2) 比较两个tensor相比较大的元素

如果要比较一个tensor和一个数字,可以使用clamp函数。

a = t.linspace(0, 15, 6).view(2, 3)
b = t.linspace(15, 0, 6).view(2, 3)
print('a=', a)
print('b=', b)
print('a[a > b]=', a[a > b])
print('t.max(a)=', t.max(a))
print('t.max(b, dim = 1)=', t.max(b, dim = 1))
print('t.max(a, b)=', t.max(a, b))

运行结果:

a= tensor([[ 0.,  3.,  6.],
        [ 9., 12., 15.]])
b= tensor([[15., 12.,  9.],
        [ 6.,  3.,  0.]])
a[a > b]= tensor([ 9., 12., 15.])
t.max(a)= tensor(15.)
t.max(b, dim = 1)= (tensor([15.,  6.]), tensor([0, 0]))
t.max(a, b)= tensor([[15., 12.,  9.],
        [ 9., 12., 15.]])

八、线性代数

pytorch的线性函数主要封装了Blas和Lapack。常用的线性代数函数如下:

 

矩阵的转置会导致存储空间不连续,需要调用它的.contiguous方法将其转为连续。

九、Tensor和Numpy

numpy和tensor共享内存。当输入数组的某个维度的长度为1时,计算时沿此维度复制扩充成一样的形状。

广播的手动实现:

(1)unsqueeze或view:为数据某一维的形状补1;

(2)expand或expand_as:重复数组。不会占用额外的空间(repeat会复制多份数据,所以会占用额外空间)。

Numpy的广播法则:

(1)所有输入数组都向shape最长的数组看齐,shape中不足的部分通过在前面加1维补齐;

(2)两个数组要么在某一个维度上的长度一致,要么其中一个为1,否则不能计算。

尽量使用向量化计算,少用for循环。

大多数t.function都有一个参数out,产生的结果可以保存在out指定的tensor中。

t.set_printoptions可以用来设置打印tensor时的数值精度和格式。

十、练习:线性回归

代码:

import torch.nn as nn
import torch as t
from torch.autograd import Variable
import torch.nn.functional as F
import torch.optim as optim
import torchvision as tv
import torchvision.transforms as transforms
from torchvision.transforms import ToPILImage
from matplotlib import pyplot as plt

# 设置随机数种子,保证在不同的计算机上运行时产生的输出一致
t.manual_seed(1000)

def get_fake_data(batch_size = 8):
    # 产生随机数据,加入噪声
    x = t.rand(batch_size, 1) * 20
    y = x * 2 + (1 + t.randn(batch_size, 1)) * 3
    return x, y

x, y = get_fake_data()

# 随机初始化参数
w = t.rand(1, 1)
b = t.zeros(1, 1)

lr = 0.001

for ii in range(20000):
    # forward
    y_pred = x.mm(w) + b.expand_as(y)
    loss = 0.5 * (y_pred - y) ** 2
    loss = loss.sum()

    # backward
    dloss = 1
    dy_pred = dloss * (y_pred - y)

    dw = x.t().mm(dy_pred)
    db = dy_pred.sum()

    # update parameters
    w.sub_(lr * dw)
    b.sub_(lr * db)

x2 = t.arange(0, 20, 1.0).view(-1, 1)
y2 = x2.mm(w) + b

plt.plot(x2.numpy(), y2.numpy())
plt.scatter(x.squeeze().numpy(), y.squeeze().numpy())
plt.show()

运行结果:

o
粉丝 0
博文 500
码字总数 0
作品 0
私信 提问
加载中
请先登录后再评论。
深度学习框架PyTorch一书的学习-第一/二章

参考https://github.com/chenyuntc/pytorch-book/tree/v1.0 希望大家直接到上面的网址去查看代码,下面是本人的笔记 pytorch的设计遵循tensor-> variable(autograd)-> nn.Module三个由低到高...

osc_ln5f29as
2019/03/28
8
0
PyTorch使用总览

PyTorch使用总览 https://blog.csdn.net/u014380165/article/details/79222243 深度学习框架训练模型时的代码主要包含数据读取、网络构建和其他设置三方面,基本上掌握这三方面就可以较为灵活...

osc_uarhdl2n
2018/09/03
3
0
pytorch 学习问题

https://pytorch.org/tutorials/beginner/blitz/neuralnetworks_tutorial.html#sphx-glr-beginner-blitz-neural-networks-tutorial-py 概述: (1) torch.Tensor——多维数组 (2) autogr......

osc_44fs053n
2018/06/15
1
0
Pytorch 基础

Pytorch 1.0.0 学习笔记: Pytorch 的学习可以参考:Welcome to PyTorch Tutorials Pytorch 是什么? 快速上手 Pytorch! Tensors(张量) 创建一个没有初始化的 $5times 3$ 矩阵: 创建一个已经...

osc_eul3o28k
2019/03/06
5
0
莫烦pytorch学习笔记(二)——variable

1.简介 torch.autograd.Variable是Autograd的核心类,它封装了Tensor,并整合了反向传播的相关实现 Variable和tensor的区别和联系Variable是篮子,而tensor是鸡蛋,鸡蛋应该放在篮子里才能方...

osc_8cfq8uoa
2019/08/16
1
0

没有更多内容

加载失败,请刷新页面

加载更多

eclipse汉化教程(附安装包)

eclipse汉化包安装步骤 一、去官网或者在本站下载Eclipse(不管是什么版,中文设置的方法都是差不多的,所以说我们汉化的教程不管未来更新多少个版本都是一样的) 官方下载地址:www.eclipse.o...

树懒宝宝
21分钟前
22
0
CocosCreator之分层管理的ListView

前言 进入公众号回复listview即可获得demo的git地址。 之前写的一篇文章《Creator之ScrollView那些事》中提到了官方Demo中提供的ListViewCtl,只是实现了纵向滑动,没有实现横向滑动。并且建议...

陈广文
24分钟前
24
0
在CSS Flexbox中,为什么没有“ justify-items”和“ justify-self”属性?

问题: Consider the main axis and cross axis of a flex container: 考虑伸缩容器的主轴和横轴: Source: W3C 资料来源: W3C To align flex items along the main axis there is one pro......

法国红酒甜
26分钟前
17
0
搜索解决方案 - ElasticSearch/Solr/Lucene

搜索解决方案 - ElasticSearch/Solr/Lucene 1. 什么是 ElasticSearch ElasticSearch 是一个基于 Lucene 的搜素服务器 是一个分布式、高扩展、实时的搜素与数据分析引擎 基于 RESTful web 接口...

夙梦o
30分钟前
26
0
设计模式学习笔记(五):工厂方法模式

1 前言 尽管简单工厂模式实现了对象的创建和使用分离,但是仍然存在以下两个问题: 工厂类过于庞大,包含了大量的判断代码,导致维护和测试难度增大 系统扩展不灵活,如果增加了新的产品类型...

氷泠
33分钟前
21
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部