pytorch重学篇——02使用numpy实现一个简单的双层网络

numpy版：

import numpy as np
N, D_in, H, D_out = 64, 1000, 100, 10
# N:batch 大小， D_in 输入维度， H 隐藏层维度， D_out输出维度

x = np.random.randn(N, D_in)
y = np.random.randn(N, D_out)

w1 = np.random.randn(D_in, H)
# w1第一层的参数
w2 = np.random.randn(H, D_out)
# w2第二层的参数

lr = 1e-6
# lr表示学习率
for t in range(500):
    #  Forward
    h = x.dot(w1)
    h_relu = np.maximum(h, 0)    # 利用maximum实现激活层
    y_pred = h_relu.dot(w2)

    # 计算损失值且打印

    loss = np.square(y_pred - y).sum()        # （虽然不是方差）方差*矩阵元素个数来计算损失
    print(t, loss)

    # backward 求导（详见下面解释）
    grad_y_pred = 2.0 * (y_pred - y)
    grad_w2 = h_relu.T.dot(grad_y_pred)
    grad_h_relu = grad_y_pred.dot(w2.T)
    grad_h = grad_h_relu.copy()
    grad_h[h<0] = 0
    grad_w1 = x.T.dot(grad_h)

    # update
    w1 -= lr * grad_w1
    w2 -= lr * grad_w2

先来简单介绍一下这个网络：

batch：批量大小，怎么理解这个批量呢？比如说你一共有1000个样本，但是每一次迭代把这一千个样本全部计算耗费时间长，所以每一次迭代我们从这一千个样本中只取出batch个计算，下一次取另外batch个，这样减少计算量。

D_in： 输入的维度大小，这里是1000，表示一个1 * 1000的向量，其形状为（1000）

H：中间层（隐藏层）维度大小，同上

D_out：输出维度，同上。输出维度如何确定？根据实际问题来确定，假设是一个经典的分类问题（手写数字识别），那么输出应该是类别种类数。

这里因为输入维度是1000，可以简单的理解Xn 的n是1000，总共1000个输入特征，经过中间的隐藏层，1000 * 100 输出形状应该是64 * 100， 再经过W2 100 * 10 得到的最终输出应该是 64 * 10.这样经过这个网络得到的结果就可以和我们真正的结果（有）进行比较，然后计算出损失值（评判网络的准确率）。

反向求导的过程是这样的：首先求出损失值对y的预测值的导数，由于loss = （y_pred-y）^2 , 则，其导数应该是2.0 * (y_pred - y)，我们最终的结果是要尽可能的减小损失值（100%理论上是绝对不可能的），然后再一步步计算w1，w2的导数，最后利用求出的导数以及学习率更新w1 以及w2。

基本就是上面这个过程，那么上面这个简单的网络使用pytorch应该是怎样实现的呢：

import  torch, torch.nn

class Net(torch.nn.Module):
    def __init__(self, N_in, H, N_out):
        super(Net, self).__init__()
        self.Conv1 = torch.nn.Linear(N_in, H)
        self.Conv2 = torch.nn.Linear(H, N_out)

    def forward(self, input):
        x1 = self.Conv1(input)
        output = self.Conv2(x1)
        return output


N, D_in, H, D_out = 64, 1000, 100, 10
x = torch.randn(N, D_in)
y = torch.randn(N, D_out)

net = Net(D_in, H, D_out)
criterion = torch.nn.MSELoss(reduction='sum')
optimizer = torch.optim.SGD(net.parameters(), lr=1e-4)
for t in range(500):
    y_pred = net(x)
    loss = criterion(y_pred, y)
    if t % 100 == 99:
        print(t, loss)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()