Pytorch快速入门0

1
2
3
4
5

# win+python3.6
pip3 install https://download.pytorch.org/whl/cu80/torch-1.0.0-cp36-cp36m-win_amd64.whl
pip3 install torchvision
# win+python3.6+conda
conda install pytorch torchvision cuda80 -c pytorch

1
2
3
4
5
6

torch.device('cuda:0')
# device(type='cuda', index=0)
torch.device('cpu')
# device(type='cpu')
torch.device('cuda', 0)
# device(type='cuda', index=0)

1
2
3
4
5

# Example of a function that takes in a torch.device
cuda1 = torch.device('cuda:1')
torch.randn((2,3), device=cuda1)
# You can substitute the torch.device with a string
torch.randn((2,3), 'cuda:1')

1
2
3
4
5
6

x = torch.Tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
x.stride()
# (5, 1)

x.t().stride()
# (1, 5)

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

# 构建 5x3 矩阵，只是分配了空间，未初始化
x = t.Tensor(5, 3)
x = t.Tensor([[1,2],[3,4]])
# tensor([[ 1.,  2.],
#         [ 3.,  4.]])
# 使用[0,1]均匀分布随机初始化二维数组
x = t.rand(5, 3)  
# tensor([[ 0.8052,  0.7188,  0.0332],
#         [ 0.6054,  0.8955,  0.8972],
#         [ 0.1107,  0.3319,  0.0336],
#         [ 0.2394,  0.5188,  0.2201],
#         [ 0.9730,  0.9370,  0.5677]])
x.size()[1], x.size(1) # 查看列的个数, 两种写法等价
# (3,3)

 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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

# 加减乘除运算
y = t.rand(5, 3)
# 加法的第一种写法
x + y
# tensor([[ 0.9639,  0.8763,  0.2834],
#         [ 1.3785,  1.5090,  1.3919],
#         [ 0.7139,  0.6348,  0.8439],
#         [ 0.7022,  1.5079,  0.4776],
#         [ 1.7892,  1.6383,  0.7774]])
# 加法的第二种写法
t.add(x, y)
# tensor([[ 0.9639,  0.8763,  0.2834],
#         [ 1.3785,  1.5090,  1.3919],
#         [ 0.7139,  0.6348,  0.8439],
#         [ 0.7022,  1.5079,  0.4776],
#         [ 1.7892,  1.6383,  0.7774]])
# 加法的第三种写法：指定加法结果的输出目标为result
result = t.Tensor(5, 3) # 预先分配空间
t.add(x, y, out=result) # 输入到result
# tensor([[ 0.9639,  0.8763,  0.2834],
#         [ 1.3785,  1.5090,  1.3919],
#         [ 0.7139,  0.6348,  0.8439],
#         [ 0.7022,  1.5079,  0.4776],
#         [ 1.7892,  1.6383,  0.7774]])

print('最初y')
print(y)
# tensor([[ 0.1587,  0.1575,  0.2501],
#         [ 0.7732,  0.6135,  0.4947],
#         [ 0.6033,  0.3029,  0.8103],
#         [ 0.4628,  0.9891,  0.2575],
#         [ 0.8163,  0.7013,  0.2097]])

print('第一种加法，y的结果')
y.add(x) # 普通加法，不改变y的内容
print(y)
# 第一种加法，y的结果
# tensor([[ 0.1587,  0.1575,  0.2501],
#         [ 0.7732,  0.6135,  0.4947],
#         [ 0.6033,  0.3029,  0.8103],
#         [ 0.4628,  0.9891,  0.2575],
#         [ 0.8163,  0.7013,  0.2097]])

print('第二种加法，y的结果')
y.add_(x) # inplace 加法，y变了
print(y)
# 第二种加法，y的结果
# tensor([[ 0.9639,  0.8763,  0.2834],
#         [ 1.3785,  1.5090,  1.3919],
#         [ 0.7139,  0.6348,  0.8439],
#         [ 0.7022,  1.5079,  0.4776],
#         [ 1.7892,  1.6383,  0.7774]])

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

a = t.ones(5) # 新建一个全1的Tensor
# tensor([ 1.,  1.,  1.,  1.,  1.])
b = a.numpy() # Tensor -> Numpy
# array([1., 1., 1., 1., 1.], dtype=float32)

a = np.ones(5)
b = t.from_numpy(a) # Numpy->Tensor
print(a)
# [1. 1. 1. 1. 1.]
print(b) 
# tensor([ 1.,  1.,  1.,  1.,  1.], dtype=torch.float64)

# 共享内存，修改numpy会修改tensor
b.add_(1) # 以`_`结尾的函数会修改自身
print(a)
# [2. 2. 2. 2. 2.]
print(b) # Tensor和Numpy共享内存
# tensor([ 2.,  2.,  2.,  2.,  2.], dtype=torch.float64)

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

scalar = b[0]
# tensor(2., dtype=torch.float64)
scalar.size() #0-dim
# torch.Size([])
scalar.item() # 使用scalar.item()能从中取出python对象的数值
# 2.0
tensor = t.tensor([2]) # 注意和scalar的区别
tensor,scalar
# (tensor([ 2]), tensor(2., dtype=torch.float64))
tensor.size(),scalar.size()
# (torch.Size([1]), torch.Size([]))
# 只有一个元素的tensor也可以调用`tensor.item()`
tensor.item(), scalar.item()
# (2, 2.0)

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

tensor = t.tensor([3,4]) # 新建一个包含 3，4 两个元素的tensor
# 以下可以看到，新建的tensor与原来的数据不共享内存
old_tensor = tensor
new_tensor = t.tensor(old_tensor)
new_tensor[0] = 1111
# old_tensor, new_tensor
# (tensor([ 3,  4]), tensor([ 1111,     4]))

# 以下使用detach新建tensor会共享内存
new_tensor = old_tensor.detach()
new_tensor[0] = 1111
# old_tensor, new_tensor
# (tensor([ 1111,     4]), tensor([ 1111,     4]))

 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

# 1.指定tensor的形状
a = t.Tensor(2, 3)
# 2.用list的数据创建tensor
b = t.Tensor([[1,2,3],[4,5,6]])
b_size = b.size()
b.tolist() # 把tensor转为list
b.numel() # b中元素总个数，2*3，等价于b.nelement()
# 3.创建一个和b形状一样的tensor
c = t.Tensor(b_size)
# 4.创建一个元素为2和3的tensor
d = t.Tensor((2, 3))
# 其他的新建Tensor的操作
t.ones(2, 3) # 全1
t.zeros(2, 3) #　全0
t.arange(1, 6, 2) #　生成序列
t.linspace(1, 10, 3) # 生成序列
t.randn(2, 3, device=t.device('cpu')) # 生成随机数
t.randperm(5) # 长度为5的随机排列
t.eye(2, 3, dtype=t.int) # 对角线为1, 不要求行列数一致

# torch.tensor()是新增加的函数，使用的方法，和参数几乎和`np.array`完全一致
scalar = t.tensor(3.14159) 
print('scalar: %s, shape of sclar: %s' %(scalar, scalar.shape))
#　scalar: tensor(3.1416), shape of sclar: torch.Size([])
t.tensor([[0.11111, 0.222222, 0.3333333]],
                     dtype=t.float64,
                     device=t.device('cpu'))
# tensor([[ 0.1111,  0.2222,  0.3333]], dtype=torch.float64)
empty_tensor = t.tensor([])
empty_tensor.shape
# torch.Size([0])

 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 as t 

a = t.arange(0, 6)
a.view(2, 3)
# tensor([[ 0.,  1.,  2.],
#         [ 3.,  4.,  5.]])
b = a.view(-1, 3) # 当某一维为-1的时候，会自动计算它的大小
b.shape
# torch.Size([2, 3])
b.unsqueeze(1) # 注意形状，在第1维（下标从0开始）上增加“１” 维
#等价于 b[:,None]
b[:, None].shape
# torch.Size([2, 1, 3])
b.unsqueeze(-2) # -2表示倒数第二个维度上面增加“1’维
c = b.view(1, 1, 1, 2, 3)
c.shape
# torch.Size([1, 1, 1, 2, 3])
c.squeeze_(0) # 压缩第0维的“１”
c.shape
# torch.Size([1, 1, 2, 3])
c.squeeze() # 把所有维度为“1”的压缩降维
# view之后和原来的数据共享
a[1] = 100
b # a修改，b作为view之后的，也会跟着修改
# tensor([[   0.,  100.,    2.],
#         [   3.,    4.,    5.]])
# reseize尺寸小于原尺寸，部分数据会被保留，不显示
b.resize_(1, 3)
b
# tensor([[   0.,  100.,    2.]])
# resize尺寸大于原尺寸，如果有隐藏数据会显示，其他多出的大小会被分配新空间
b.resize_(3, 3) # 旧的数据依旧保存着，多出的大小会分配新空间
b
# tensor([[   0.0000,  100.0000,    2.0000],
#         [   3.0000,    4.0000,    5.0000],
#         [  -0.0000,    0.0000,    0.0000]])

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

import torch as t 

# 生成数据
a = t.arange(0, 6).view(2, 3)
t.cos(a)
# tensor([[1.0000000000, 0.5403022766, -0.4161468446],
#         [-0.9899924994, -0.6536436081, 0.2836622000]])
a % 3 # 等价于t.fmod(a, 3)
# tensor([[ 0.,  1.,  2.],
#         [ 0.,  1.,  2.]])
t.clamp(a, min=3)
# tensor([[ 3.,  3.,  3.],
#         [ 3.,  4.,  5.]])

1
2
3
4
5
6
7
8
9

import torch as t 

# 生成数据
b = t.ones(2, 3)
b.sum(dim = 0, keepdim=True)
# tensor([[ 2.,  2.,  2.]])
# keepdim=False，不保留维度"1"，注意形状
b.sum(dim=0, keepdim=False)
# tensor([ 2.,  2.,  2.])

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

import torch as t 

# 生成数据a
a = t.linspace(0, 15, 6).view(2, 3)
a
# tensor([[  0.,   3.,   6.],
#         [  9.,  12.,  15.]])
# 生成数据b
b = t.linspace(15, 0, 6).view(2, 3)
b
# tensor([[ 15.,  12.,   9.],
#         [  6.,   3.,   0.]])
a[a>b] # a中大于b的元素
# tensor([  9.,  12.,  15.])
t.max(b, dim=1) 
# 第一个返回值的15和6分别表示第0行和第1行最大的元素
# 第二个返回值的0和0表示上述最大的数是该行第0个元素
# (tensor([ 15.,   6.]), tensor([ 0,  0]))

 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

import torch as t

# 生成数据a和b
a = t.ones(3, 2)
b = t.zeros(2, 3,1)
# 自动广播法则
# 第一步：a是2维,b是3维，所以先在较小的a前面补1 ，
#               即：a.unsqueeze(0)，a的形状变成（1，3，2），b的形状是（2，3，1）,
# 第二步:   a和b在第一维和第三维形状不一样，其中一个为1 ，
#               可以利用广播法则扩展，两个形状都变成了（2，3，2）
a+b
# tensor([[[ 1.,  1.],
#          [ 1.,  1.],
#          [ 1.,  1.]],

#         [[ 1.,  1.],
#          [ 1.,  1.],
#          [ 1.,  1.]]])
# 手动广播法则
# 或者 a.view(1,3,2).expand(2,3,2) + b.expand(2,3,2)
a[None].expand(2, 3, 2) + b.expand(2,3,2)
# tensor([[[ 1.,  1.],
#          [ 1.,  1.],
#          [ 1.,  1.]],

#         [[ 1.,  1.],
#          [ 1.,  1.],
#          [ 1.,  1.]]])
# expand不会占用额外空间，只会在需要的时候才扩充，可极大节省内存
e = a.unsqueeze(0).expand(10000000000000, 3,2)

 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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

import torch as t 
# 生成数据a
a = t.arange(0, 6)
# 查看a的storage
a.storage()
#  0.0
#  1.0
#  2.0
#  3.0
#  4.0
#  5.0
# [torch.FloatStorage of size 6]
# b由a view生成
b = a.view(2, 3)
# 查看b的storage
b.storage()
#  0.0
#  1.0
#  2.0
#  3.0
#  4.0
#  5.0
# [torch.FloatStorage of size 6]

# 一个对象的id值可以看作它在内存中的地址
# storage的内存地址一样，即是同一个storage
id(b.storage()) == id(a.storage())
# True

# a改变，b也随之改变，因为他们共享storage
a[1] = 100
b
# tensor([[   0.,  100.,    2.],
#         [   3.,    4.,    5.]])
# c由a切片得到
c = a[2:] 
c.storage()
# 0.0
# 100.0
# 2.0
# 3.0
# 4.0
# 5.0
# [torch.FloatStorage of size 6]
c.data_ptr(), a.data_ptr() # data_ptr返回tensor首元素的内存地址
# 可以看出相差8，这是因为2*4=8--相差两个元素，每个元素占4个字节(float)
# (93894489135160, 93894489135152)
c[0] = -100 # c[0]的内存地址对应a[2]的内存地址
a
# tensor([   0.,  100., -100.,    3.,    4.,    5.])
# 使用storage来初始化Tensor
d = t.Tensor(c.storage())
d[0] = 6666
b
# tensor([[ 6666.,   100.,  -100.],
#         [    3.,     4.,     5.]])
# 下面４个tensor共享storage
id(a.storage()) == id(b.storage()) == id(c.storage()) == id(d.storage())
# True
a.storage_offset(), c.storage_offset(), d.storage_offset()
# (0, 2, 0)
# 切片得到e
e = b[::2, ::2] # 隔2行/列取一个元素
id(e.storage()) == id(a.storage())
# True
b.stride(), e.stride()
# ((3, 1), (6, 2))
# e的数据变得不连续
e.is_contiguous()
# False

1
2
3
4
5
6
7

import torch as t
# 生成数据
a = t.randn(3, 4)
a.device
# device(type='cpu')
device = t.device('gpu')
a.to(device)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

if t.cuda.is_available():
    a = a.cuda(1) # 把a转为GPU1上的tensor,
    t.save(a,'a.pth')

    # 加载为b, 存储于GPU1上(因为保存时tensor就在GPU1上)
    b = t.load('a.pth')
    # 加载为c, 存储于CPU
    c = t.load('a.pth', map_location=lambda storage, loc: storage)
    # 加载为d, 存储于GPU0上
    d = t.load('a.pth', map_location={'cuda:1':'cuda:0'})

 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

import torch as t 

def f(x):
    '''计算y'''
    y = x**2 * t.exp(x)
    return y

def gradf(x):
    '''手动求导函数'''
    dx = 2*x*t.exp(x) + x**2*t.exp(x)
    return dx
  
# 生成数据，由于对x求导，所以设定requires_grad = True
x = t.randn(3,4, requires_grad = True)
y = f(x)
y
# tensor([[ 0.0928,  0.1978,  0.6754,  0.8037],
#         [ 0.9882,  0.3546,  0.2380,  0.0002],
#         [ 0.2863,  0.0448,  0.1516,  2.9122]])
# 此处要注意，对于backward需要传入gradient的尺寸
y.backward(t.ones(y.size())) # gradient形状与y一致
x.grad
# tensor([[ -0.4611,  62.0520,  35.2313,   4.8159],
#         [  1.2937,   2.5127,  -0.2839,  -0.4043],
#         [ -0.3389,   1.9795,   1.6028,   2.0199]])
# 可以看得出来，手动求导的结果和自动求导的结果一致
gradf(x)
# tensor([[ -0.4611,  62.0520,  35.2313,   4.8159],
#         [  1.2937,   2.5127,  -0.2839,  -0.4043],
#         [ -0.3389,   1.9795,   1.6028,   2.0199]])

 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
37
38
39
40

import torch as t
# 为tensor设置 requires_grad 标识，代表着需要求导数
# pytorch 会自动调用autograd 记录操作
x = t.ones(2, 2, requires_grad=True)

# 上一步等价于
# x = t.ones(2,2)
# x.requires_grad = True
x
# tensor([[ 1.,  1.],
#         [ 1.,  1.]])
y = x.sum()
y
# tensor(4.)
y.grad_fn
# <SumBackward0 at 0x7ffaa589a780>
y.backward() # 反向传播,计算梯度
# y = x.sum() = (x[0][0] + x[0][1] + x[1][0] + x[1][1])
# 每个值的梯度都为1
x.grad 
# tensor([[ 1.,  1.],
#         [ 1.,  1.]])

# 反向传播的时候，梯度注意需要清零
# 未清零，此时的梯度为
y.backward()
x.grad
# tensor([[ 2.,  2.],
#         [ 2.,  2.]])
y.backward()
x.grad
# tensor([[ 3.,  3.],
#         [ 3.,  3.]])
# 清零之后的反向传播
# 以下划线结束的函数是inplace操作，会修改自身的值，就像add_
x.grad.data.zero_()
y.backward()
x.grad
# tensor([[ 1.,  1.],
#         [ 1.,  1.]])

 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
37
38
39
40

import torch as t

# 测试requires_grad
x = t.ones(1)
b = t.rand(1, requires_grad = True)
w = t.rand(1, requires_grad = True)
y = w * x # 等价于y=w.mul(x)
z = y + b # 等价于z=y.add(b)
x.requires_grad, b.requires_grad, w.requires_grad
# (False, True, True)
# 在默认情况下，requires_grad会自动传递
# 虽然未指定y.requires_grad为True，但由于y依赖于需要求导的w
# 故而y.requires_grad为True
y.requires_grad
# True
# 计算图的叶子节点
x.is_leaf, w.is_leaf, b.is_leaf
# (True, True, True)
y.is_leaf, z.is_leaf
# (False, False)
# grad_fn可以查看这个variable的反向传播函数，
# z是add函数的输出，所以它的反向传播函数是AddBackward
z.grad_fn 
# <AddBackward1 at 0x7f60b09c2630>
# next_functions保存grad_fn的输入，是一个tuple，tuple的元素也是Function
# 第一个是y，它是乘法(mul)的输出，所以对应的反向传播函数y.grad_fn是MulBackward
# 第二个是b，它是叶子节点，由用户创建
z.grad_fn.next_functions 
# ((<MulBackward1 at 0x7f60b09c2278>, 0),
# (<AccumulateGrad at 0x7f60b09c2198>, 0))
# variable的grad_fn对应着和图中的function相对应
z.grad_fn.next_functions[0][0] == y.grad_fn

# 第一个是w，叶子节点，需要求导，梯度是累加的
# 第二个是x，叶子节点，不需要求导，所以为None
y.grad_fn.next_functions
# ((<AccumulateGrad at 0x7f60b09c2898>, 0), (None, 0))
# 叶子节点的grad_fn是None
w.grad_fn,x.grad_fn
# (None, None)

 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

# 两种抑制requires_grad传递的方法
x = t.ones(1, requires_grad=True)
w = t.rand(1, requires_grad=True)
y = x * w
# y依赖于w，而w.requires_grad = True
x.requires_grad, w.requires_grad, y.requires_grad
# (True, True, True)
# 1.第一种抑制的方法
with t.no_grad():
    x = t.ones(1)
    w = t.rand(1, requires_grad = True)
    y = x * w
# y依赖于w和x，虽然w.requires_grad = True，但是y的requires_grad依旧为False
x.requires_grad, w.requires_grad, y.requires_grad
# (False, True, False)
# 2.第二种抑制的方法
t.set_grad_enabled(False)
x = t.ones(1)
w = t.rand(1, requires_grad = True)
y = x * w
# y依赖于w和x，虽然w.requires_grad = True，但是y的requires_grad依旧为False
x.requires_grad, w.requires_grad, y.requires_grad
# (False, True, False)
# 恢复默认配置
t.set_grad_enabled(True)

 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
37
38

import torch as t 
# 中间节点，梯度自动清零
x = t.ones(3, requires_grad=True)
w = t.rand(3, requires_grad=True)
y = x * w
# y依赖于w，而w.requires_grad = True
z = y.sum()
x.requires_grad, w.requires_grad, y.requires_grad
# (True, True, True)
# 非叶子节点grad计算完之后自动清空，y.grad是None
z.backward()
(x.grad, w.grad, y.grad)
# (tensor([ 0.2709,  0.0473,  0.5052]), tensor([ 1.,  1.,  1.]), None)
# 第一种方法：使用grad获取中间变量的梯度
x = t.ones(3, requires_grad=True)
w = t.rand(3, requires_grad=True)
y = x * w
z = y.sum()
# z对y的梯度，隐式调用backward()
t.autograd.grad(z, y)
# (tensor([ 1.,  1.,  1.]),)

# 第二种方法：使用hook
# hook是一个函数，输入是梯度，不应该有返回值
def variable_hook(grad):
    print('y的梯度：',grad)

x = t.ones(3, requires_grad=True)
w = t.rand(3, requires_grad=True)
y = x * w
# 注册hook
hook_handle = y.register_hook(variable_hook)
z = y.sum()
z.backward()

# 除非你每次都要用hook，否则用完之后记得移除hook
hook_handle.remove()
# y的梯度： tensor([ 1.,  1.,  1.])

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

import torch as t 

# 默认参数下的反向传播，默认情况下，z必须是标量
x = t.arange(0,3, requires_grad=True)
y = x**2 + x*2
z = y.sum()
z.backward() # 从z开始反向传播
x.grad
# tensor([ 2.,  4.,  6.])
# 指定Variable的反向传播，如果z不是标量，不指定Variable，会出错
x = t.arange(0,3, requires_grad=True)
y = x**2 + x*2
z = y.sum()
y_gradient = t.Tensor([1,1,1]) # dz/dy
y.backward(y_gradient) #从y开始反向传播
x.grad
# tensor([ 2.,  4.,  6.])

 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

from torch.autograd import Function
class MultiplyAdd(Function):
                                                            
    @staticmethod
    def forward(ctx, w, x, b):                              
        ctx.save_for_backward(w,x)
        output = w * x + b
        return output
        
    @staticmethod
    def backward(ctx, grad_output):                         
        w,x = ctx.saved_tensors
        grad_w = grad_output * x
        grad_x = grad_output * w
        grad_b = grad_output * 1
        return grad_w, grad_x, grad_b             
      
      
x = t.ones(1)
w = t.rand(1, requires_grad = True)
b = t.rand(1, requires_grad = True)
# 开始前向传播
z=MultiplyAdd.apply(w, x, b)
# 开始反向传播
z.backward()
# x不需要求导，中间过程还是会计算它的导数，但随后被清空
x.grad, w.grad, b.grad
# (None, tensor([ 1.]), tensor([ 1.]))

 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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

import torch as t
%matplotlib inline
from matplotlib import pyplot as plt
from matplotlib import style
from IPython import display
style.use("ggplot")


device = t.device('cuda') #如果你想用gpu，改成t.device('cuda:0')

# 设置随机数种子，保证在不同电脑上运行时下面的输出一致
t.manual_seed(1000) 

def get_fake_data(batch_size=8):
    ''' 产生随机数据：y=x*2+3，加上了一些噪声'''
    x = t.rand(batch_size, 1, device=device) * 5
    y = x * 2 + 3 +  t.randn(batch_size, 1, device=device)
    return x, y 
  
# 随机初始化参数
w = t.rand(1, 1).to(device)
b = t.zeros(1, 1).to(device)

lr =0.02 # 学习率
num_epochs = 500
# 训练500次
for ii in range(num_epochs):
  	# 获取数据
    x, y = get_fake_data(batch_size=4)
    
    # forward：计算loss
    y_pred = x.mm(w) + b.expand_as(y) # x@W等价于x.mm(w);for python3 only
    loss = 0.5 * (y_pred - y) ** 2 # 均方误差
    loss = loss.mean()
    
    # backward：手动计算梯度
    # 模拟计算图的方式计算误差
    dloss = 1
    dy_pred = dloss * (y_pred - y)
    
    dw = x.t().mm(dy_pred)
    db = dy_pred.sum()
    
    # 更新参数
    w.sub_(lr * dw)
    b.sub_(lr * db)
    
    if ii%50 ==0:
        # 画图
        # 使用display实现动态图
        display.clear_output(wait=True)
        x = t.arange(0, 6).view(-1, 1).to(device)
        y = x.mm(w) + b.expand_as(x)
        plt.plot(x.cpu().numpy(), y.cpu().numpy(),c = 'green') # predicted
        
        x2, y2 = get_fake_data(batch_size=32) 
        plt.scatter(x2.cpu().numpy(), y2.cpu().numpy()) # true data
        
        plt.xlim(0, 5)
        plt.ylim(0, 13)
        plt.show()
        plt.pause(0.5)
        
print('w: ', w.item(), 'b: ', b.item())

 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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

import torch as t
%matplotlib inline
from matplotlib import pyplot as plt
from matplotlib import style
from IPython import display
style.use("ggplot")


# 注意，此处如果使用cuda，那么计算梯度的时候，会出错
device = t.device('cpu') 

# 设置随机数种子，保证在不同电脑上运行时下面的输出一致
t.manual_seed(1000) 

def get_fake_data(batch_size=8):
    ''' 产生随机数据：y=x*2+3，加上了一些噪声'''
    x = t.rand(batch_size, 1, device=device) * 5
    y = x * 2 + 3 +  t.randn(batch_size, 1, device=device)
    return x, y 
  
# 随机初始化参数
w = t.rand(1, 1).to(device)
b = t.zeros(1, 1).to(device)

lr =0.02 # 学习率
num_epochs = 500
# 训练500次

for ii in range(num_epochs):
    x, y = get_fake_data(batch_size=32)
    
    # forward：计算loss
    y_pred = x.mm(w) + b.expand_as(y)
    loss = 0.5 * (y_pred - y) ** 2
    loss = loss.sum()
    losses[ii] = loss.item()
    
    # backward：手动计算梯度
    loss.backward()
    
    # 更新参数
    w.data.sub_(lr * w.grad.data)
    b.data.sub_(lr * b.grad.data)
    
    # 梯度清零
    w.grad.data.zero_()
    b.grad.data.zero_()
    
    if ii % 10 ==0:
        # 画图
        display.clear_output(wait=True)
        x = t.arange(0, 6).view(-1, 1)
        y = x.mm(w.data) + b.data.expand_as(x)
        plt.plot(x.numpy(), y.numpy(),c = 'blue') # predicted
        print(w.item(),b.item())
        
        x2, y2 = get_fake_data(batch_size=20) 
        plt.scatter(x2.numpy(), y2.numpy()) # true data
        
        plt.xlim(0,5)
        plt.ylim(0,13)   
        plt.show()
        plt.pause(0.5)
        
print(w.item(), b.item())
# 1.9642277956008911 3.0166714191436768

 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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

import torch as t
%matplotlib inline
from matplotlib import pyplot as plt
from torch import optim
from torch import nn 
from matplotlib import style
from IPython import display
style.use("ggplot")


# 不知道为啥使用cuda梯度为不存在了
device = t.device('cpu') 

# 设置随机数种子，保证在不同电脑上运行时下面的输出一致
t.manual_seed(1000) 

def get_fake_data(batch_size=8):
    ''' 产生随机数据：y=x*2+3，加上了一些噪声'''
    x = t.rand(batch_size, 1, device=device) * 5
    y = x * 2 + 3 +  t.randn(batch_size, 1, device=device)
    return x, y 
 
# 随机初始化参数
w = t.rand(1,1, requires_grad=True).to(device)
b = t.zeros(1,1, requires_grad=True).to(device)

lr = 0.0005 # 学习率不能太大
num_epochs = 500
losses = np.zeros(500)

# 导入优化器
opt = optim.SGD([w,b],lr = lr)
# 引入mse损失函数
loss_func = nn.MSELoss()

for ii in range(num_epochs):
    x, y = get_fake_data(batch_size=32)
    
    # forward：计算loss
    y_pred = x.mm(w) + b.expand_as(y)
    loss = loss_func(y_pred,y)
    losses[ii] = loss.item()
    # 优化器梯度清零
    opt.zero_grad()
    # backward：手动计算梯度
    loss.backward()
    # 逐步优化
    opt.step()
    
    
    if ii % 10 == 0:
        # 画图
        display.clear_output(wait=True)
        x = t.arange(0, 6).view(-1, 1)
        y = x.mm(w.data) + b.data.expand_as(x)
        plt.plot(x.numpy(), y.numpy(),c = 'blue') # predicted
        print(w.item(),b.item())
        
        x2, y2 = get_fake_data(batch_size=20) 
        plt.scatter(x2.numpy(), y2.numpy()) # true data
        
        plt.xlim(0,5)
        plt.ylim(0,13)   
        plt.show()
        plt.pause(0.5)
        
print(w.item(), b.item())