1、张量（Tensor）

在Pytorch中处理的数据都按张量来表示，张量是一个矩阵维度的单位，表示多维矩阵。

Tensor有5种基本类型

  1. 16位整型 torch.ShortTensor
  2. 32位整型 torch.IntTensor
  3. 32位浮点型 torch.FloatTensor (默认类型)
  4. 64位整型 torch.LongTensor
  5. 64位浮点型 torch.DoubleTensor

1.1、定义张量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import torch

# 3*2全为0的矩阵
print(torch.zeros([3, 2]))

# 3*2随机值的矩阵
print(torch.randn([3, 2]))

# 3*2全为1的矩阵
print(torch.ones([3, 2]))

如果想使用在GPU上定义，那么只需要在后面加上 .cuda()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import torch

# 3*2全为0的矩阵
print(torch.zeros([3, 2]).cuda())

# 3*2随机值的矩阵
print(torch.randn([3, 2]).cuda())

# 3*2全为1的矩阵
print(torch.ones([3, 2]).cuda())

# 生成相同的数值的矩阵
a = torch.full(size=[2, 3], fill_value=7.)
print(a)
"""
tensor([[7., 7., 7.],
        [7., 7., 7.]])
"""

如何判断你的环境是否支持GPU，使用这个命令

1
2
3
4

import torch

# 返回 True表示可以使用GPU
print(torch.cuda.is_available())

【注意】张量可以看作是一个多维数组，标量是0位张量，向量是1位的张量，矩阵是2位的张量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import torch

# 标量
a = torch.tensor(13.1)
print(a.dim())  # 0

# 向量
b = torch.ones(2)
print(b.dim())  # 1

# 矩阵
c = torch.randn([3, 2])
print(c.dim())  # 2

其中.dim()求维度。

Pytorch的数据类型有很多和numpy特别相似，如果要查看shape，和np一样。

1.2、维度含义

1.2.1、三维度

一般在RNN中[b,word,vector]

  • 第一位表示bitch数量
  • 第二位表示句子数量
  • 第三表示每一个句子可以用一个向量来表示

1.2.2、四维度

一般在CNN中[b,c,h,w]

  • 第一位表示bitch
  • 第二位表示图片的通道
  • 第三位表示图片长度
  • 第四位表示图片宽度

如何求张量的个数

1
2
3
4
5
6

import torch

# 生成三维全是1的矩阵
a = torch.ones(size=(2, 3, 4))
# 求一共有多少位
print(a.numel())  # 2*3*4 = 24

1.3、未初始化

不要直接使用Pytorch来创建数据，不然会出现非常大的数值，也可以是无穷大和无穷小的情况

1
2
3
4
5
6
7
8
9

import torch

# 切记不能这样生成数据，不然会出现非常大的数
a = torch.IntTensor(2, 3)
print(a)
"""
tensor([[-1339644960,         582, -1339644976],
        [        582, -1339300112,         582]], dtype=torch.int32)
"""

1.4、更改默认类型

如果声明的是浮点数，默认是 torch.FloatTensor，如果是整数，默认是 torch.LongTensor

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import torch

# 如果是浮点数，默认类型是： torch.FloatTensor
a = torch.tensor([2.0, 3])
print(a.type())  # torch.FloatTensor

# 更改默认类型
torch.set_default_tensor_type(torch.DoubleTensor)

a = torch.tensor([2.0, 3])
print(a.type())  # torch.DoubleTensor

1.5、随机数

随机生成的数使用的情况非常多，用的比较多的方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

import torch

a = torch.randint(1, 10, size=[2, 3])
print(a)
"""
tensor([[8, 7, 2],
        [6, 8, 5]])
"""

# 随机生成[0,1)之间的随机数，默认类型是 torch.FloatTensor
a = torch.rand(size=[2, 3])
print(a)
print(a.type())  # torch.FloatTensor
"""
tensor([[0.5692, 0.5389, 0.8351],
        [0.2079, 0.7725, 0.8432]])
"""

# 随机生成 正态分布（0~1)之间的随机数，默认类型是 torch.FloatTensor
a = torch.randn(size=[2, 3])
print(a)
print(a.type())  # torch.FloatTensor
"""
tensor([[ 0.3335,  0.7398,  1.3681],
        [-0.2129,  1.1837,  0.2828]])
"""

# 随机生成 正态分布（u~std)之间的随机数，默认类型是 torch.FloatTensor
# 数学表达式：N(3,5)
a = torch.normal(size=[2, 3], mean=3, std=5)
print(a)
print(a.type())  # torch.FloatTensor
"""
tensor([[ 1.3164, -5.8054,  1.5450],
        [ 4.7889, 13.1251,  2.0415]])
"""

1.6、生成数列

torch里面能生成两种数列，一种是等差数列，另一种是等分数列

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 生成等差数列，第一位是起始位，结束位，等差值，不写默认是1
a = torch.arange(0, 10)
# tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
print(a)

# 生成等分数列，第一位是起始位，结束位，等分值（必填），
# 均匀的分成多少份
b = torch.linspace(0, 10, 5)
# tensor([ 0.0000,  2.5000,  5.0000,  7.5000, 10.0000])
print(b)

【注意】：Tensor和tensor的区别

大写的Tensor和小写的tensor唯一的区别是，当只传入一位数的时候，大写的表示Size，而小写的表示标量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import torch

# 大写表示Size为1，值随机的数
print(torch.Tensor(1))  # tensor([0.])

# 小写表示size为1，值是1
print(torch.tensor(1))  # tensor(1)

# 大写表示Size为1*2，值随机的数
print(torch.Tensor(1, 2))  # tensor([[1.4013e-45, 0.0000e+00]])

# 错误语法
# print(torch.tensor(1, 2))  # 错误语法

# 小写表示Size为1*2，值是1,2，类型是整型
print(torch.tensor([1, 2]))  # tensor([1, 2])

# 大写表示Size为1*2，值是1,2，值等价上面的小写，不过类型是默认类型 Float
print(torch.Tensor([1, 2]))  # tensor([1, 2])

"""
下面这种是等价写法
print(torch.Tensor([1, 2]))
print(torch.tensor([1., 2.]))
"""

2、变量（Variable）

Pytorch的变量也是和张量一样，是一个比较重要的概念，这个和传统编程语言的变量不一样。这里的变量是加入了计算图，可以进行前向传播和反向传播、自动求导。 在变量中有三个比较重要的属性（data、grad、grad_fn），通过data获取到变量里面的值，这个值其实就是张量。grad_fn表示的是这个变量的操作，比如：是通过什么四则运算 得来的？（比如：加减乘除），最后grad是这个变量的反向梯度。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

import torch

x = torch.autograd.Variable(torch.tensor([1.]), requires_grad=True)
w = torch.autograd.Variable(torch.tensor([2.]), requires_grad=True)
b = torch.autograd.Variable(torch.tensor([3.]), requires_grad=True)
y = w * x + b

y.backward()

print(x.grad)  # tensor([2.])
print(w.grad)  # tensor([1.])
print(b.grad)  # tensor([1.])