一个简单的传播网络，从numpy写到pytorch

使用numpy完成一个简单的神经网络

import numpy as np
N, D_in, H, D_out = 64,1000,100,10
#N是训练数据；H是hidden（中间层神经元个数）；D_in_out是输入输出维度
x = np.random.randn(N,D_in)
y = np.random.randn(N,D_out)

w1 = np.random.randn(D_in,H)
w2 = np.random.randn(H,D_out)
learning_rate = 1e-6                  #learning rate太大会导致降太快

for it in range(500):                 #forward pass:向前传输 (一个神经网络模型)
    h = x.dot(w1)                     # 矩阵x乘矩阵w1: N*H的矩阵
    h_relu = np.maximum(h,0) 
    y_pred = h_relu.dot(w2)           #要么用矩阵h乘（N*H与H*D_out），要么用0乘
    
    #损失函数loss (理论上loss会越来越小)
    loss = np.square(y_pred - y).sum()
    print(it,loss)
    
    #backward pass反向梯度:最终要得到loss和w1之间的梯度关系
    #一步一步往前求导可以得到一个compute the gradient
    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 weight w1 and w2
    w1 -= learning_rate * grad_w1
    w2 -= learning_rate * grad_w2   

在numpy的基础上把代码替代成pytorch代码

先对语句替换，不使用自带的求导函数等
两个函数：
1. torch.mm(input, mat2, out=None)
Performs a matrix multiplication of the matrices input and mat2.
If input is a (n×m) tensor, mat2 is a (m×p) tensor, out will be a (n×p) tensor.
2. torch.clamp(input, min, max, out=None)
Clamp all elements in input into the range [min,max] and return a resulting tensor:
y在最大最小值之间等于x，否则等于最值
If input is of type FloatTensor or DoubleTensor, args min and max must be real numbers, otherwise they should be integers.

import numpy as np
import torch

N, D_in, H, D_out = 64,1000,100,10
x = torch.randn(N,D_in)  #np.random.randn变成torch.randn
y = torch.randn(N,D_out)

w1 = torch.randn(D_in,H)
w2 = torch.randn(H,D_out)
learning_rate = 1e-6

for it in range(500):
    h = x.mm(w1)                             #dot（点乘）变成mm（矩阵乘积）
    h_relu = h.clamp(min = 0,)               #夹子函数来写relu
    y_pred = h_relu.mm(w2)
    
    #损失函数loss (理论上loss会越来越小)
    loss = (y_pred - y).pow(2).sum().item()  #要把tenser转成数字才可以print
    print(it,loss)                           #这儿也可以 print(loss.item())
    
    #backward pass,未使用自带求导功能，手动求导基本同numpy
    grad_y_pred = 2.0 * (y_pred - y)
    grad_w2     = h_relu.t().mm(grad_y_pred)
    grad_h_relu = grad_y_pred.mm(w2.T)
    grad_h      = grad_h_relu.clone()
    grad_h[h<0] = 0
    grad_w1     = x.t().mm(grad_h)
    
    #update weight w1 and w2
    w1 -= learning_rate * grad_w1
    w2 -= learning_rate * grad_w2   

开始使用pytorch的求导功能简化代码

定义变量的时候对于变量会有一个Requires_grad = True的参数，会在后台生成一个comuptic graph，最终计算该graph里所有的grad，如果是false的话就不会进行这一步。

import torch

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

w1 = torch.randn(D_in,H,requires_grad = True) #加了requires_grad=True之后，会把梯度保存在后台
w2 = torch.randn(H,D_out,requires_grad = True)
learning_rate = 1e-6

for it in range(500):
    y_pred = x. mm(w1). clamp (min = 0). mm(w2)   #相对于上一段代码精简，把代码写到一行里
    
    #损失函数loss (理论上loss会越来越小)
    loss = (y_pred - y).pow(2).sum()   #后台一张computation graph
    print(it,loss.item())              #后面要算backward，所以这个时候不可以把item留在外面
    
    #backward pass,直接求loss的导数
    loss.backward()                    #计算机直接返回总体计算梯度
    
    #update weight w1 and w2
    with torch.no_grad():              #不用记住w1和2的计算图，
        w1 -= learning_rate * w1.grad
        w2 -= learning_rate * w2.grad   
        w1.grad.zero_()                #grad存在内存里每次都会叠加，所以在求完一次之后要清除
        w2.grad.zero_()

先写这么多吧x