numpy与pytorch实现梯度下降，实现一个简单的两层神经网络

numpy 实现梯度下降

参考教程：pytorch神经网络实践(1): 安装与初次使用pytorch搭建神经网络实践手写数字识别教程

# -*- coding: utf-8 -*-
"""
让神经元学习到逻辑与这个规则
@author: 李韬_varyshare
"""
# 先随便猜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实现梯度下降与线性回归

# -*- coding: utf-8 -*- 
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实现两层神经网络

# -*- coding: utf-8 -*- 
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_()