1.Abstract

参加DatewhalePytorch课程

2.Background

以前接触过一点,一头雾水

3.Task

【Task2(2天)】设立计算图并自动计算 1.numpy和pytorch实现梯度下降法 2.设定初始值 3.求取梯度 4.在梯度方向上进行参数的更新 5.numpy和pytorch实现线性回归 6.pytorch实现一个简单的神经网络 7.参考资料:PyTorch 中文文档 https://pytorch.apachecn.org/docs/1.0/

4.Work

numpy实现梯度下降

# 先随便猜w1,w2,b是多少
w1 = 0.666
w2 = 0.333
b = 0.233

def train():
    # 用于训练的数据(四行)一行样本数据格式为 [x1,x2,g(x1,x2)]
    data = [
            [1,  0,     -1],
            [0,  1,     -1],
            [0,  0,     -1],
            [1,  1,     1]
            ]
    global w1,w2,b # 告诉计算机我修改的是全局变量(每个函数都能修改这个变量)

    epoch = 20 # 同样的数据反复训练20次
    for _ in range(epoch):
        # 逐个样本更新权重
        for i in data:
            # 这里的i = [x1,x2,g(x1,x2)],它是data中的一行
            # 求各自导函数在(x1,x2,g(x1,x2))处的导函数值
            d_w1 = 2*(w1*i[0]+w2*i[1]+b-i[2])*i[0]
            d_w2 = 2*(w1*i[0]+w2*i[1]+b-i[2])*i[1]
            d_b = 2*(w1*i[0]+w2*i[1]+b-i[2])

            # 接下来就是愉快的理性猜环节了
            # 设置学习率,防止蹦的步子太大
            learning_rate = 0.01
            # 下次猜的数 = 本次猜的数 - 学习率*导数值
            w1_next = w1 - learning_rate*d_w1
            w2_next = w2 - learning_rate*d_w2
            b_next = b - learning_rate*d_b

            # 更新各参数
            w1 = w1_next
            w2 = w2_next
            b = b_next

            pass
        pass

def f(x1,x2):
    """
    这是一个神经元(本质就是一个表达式)
    经过训练,我们期望它的返回值是x1&x2
    返回值是 w1*x1+w2*x2 + b > 0? 1:0;
    计算这个用于判断(x0,x1)的分类。
    大于0则是点(x0,x1)在右上输出1,小于0则点在左下输出0;
    """
    global w1,w2,b # 告诉计算机我修改的是全局变量(每个函数都能修改这个变量)
    if w1*x1+w2*x2 + b > 0:
        return 1
    else:
        return 0

# 我们首先执行下训练,让神经元自己根据四条数据学习逻辑与的规则
train()
# 打印出模型计算出来的三个比较优的参数
print(w1,w2,b)
"""
输出:0.4514297388906616 0.2369025056182418 -0.611635769357402
"""

# 好我们测试下,看神经元有没有自己学习到逻辑与的规则
print("0&1",f(0,1))
print("1&0",f(1,0))
print("0&0",f(0,0))
print("1&1",f(1,1))
"""
输出:
0&1= 0
1&0= 0
0&0= 0
1&1= 1
"""

pytorch实现梯度下降与线性回归

import torch as torch
# 加载数据
data_num = 23
data_dim = 10
data = torch.randn(data_num, data_dim,dtype=torch.float)
label = torch.randn(data_num, data_dim,dtype=torch.float)

# 先用随机值初始化两层神经网络的权重
w1 = torch.randn(data_dim, 1, dtype=torch.float,requires_grad=True)

# 计算f = exp(wx+b)
output= 1/(1+torch.exp(-data.mm(w1)))
# 反向传播计算f对w1的导数
f.backward()

learning_rate = 1e-4
# 更新参数
with torch.no_grad():
    w1 -= learning_rate * w1.grad
    # 对本次计算的导数清零
    w1.grad.zero_()

pytorch实现两层神经网络

import torch as torch
# 加载数据
data_num = 233
data_dim = 10
data = torch.randn(data_num, data_dim,dtype=torch.float)
label = torch.randn(data_num, data_dim,dtype=torch.float)

# 定义2层神经网络,并设置每层神经元个数
layer1_in = data_dim
layer1_out = layer2_in = 7
layer2_out = 10

# 先用随机值初始化两层神经网络的权重
w1 = torch.randn(layer1_in, layer1_out, dtype=torch.float,requires_grad=True)
w2 = torch.randn(layer2_in, layer2_out, dtype=torch.float,requires_grad=True)

# 正向传播
output1 = data.mm(w1)
output2 = output1.clamp(min=0).mm(w2)

# 根据损失函数计算误差
loss = (output2 - label).pow(2).sum()
# 获取loss的数值
print('loss', loss.item())

# 反向传播计算导数
loss.backward()

learning_rate = 1e-4
# 更新参数
with torch.no_grad():
    w1 -= learning_rate * w1.grad
    w2 -= learning_rate * w2.grad
    # 对本次计算的导数清零
    w1.grad.zero_()
    w2.grad.zero_()