用numpy实现两层神经网络
一个全连接ReLU神经网络，一个隐藏层，没有bias。用来从x预测y，使用L2 Loss。
- ℎ=𝑊1𝑋h=W1X
- 𝑎=𝑚𝑎𝑥(0,ℎ)a=max(0,h)
- 𝑦ℎ𝑎𝑡=𝑊2𝑎yhat=W2a
这一实现完全使用numpy来计算前向神经网络，loss，和反向传播。
- forward pass
- loss
- backward pass
numpy实现：
import numpy as np
N,D_in,H,D_out = 64,1000,100,10 #64个数，1000维的输入，100个隐层，10维输出
#把1000维降到10维输出
#随机创建一些训练数据
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
#训练500次
for t in range(500):
#Forward
h = x.dot(w1) #N*H
h_relu = np.maximum(h,0)
y_pred = h_relu.dot(w2) #N*D_out
# compute loss
loss = np.square(y_pred-y).sum() #均方误差
print(t,loss)
#Backward pass
#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 weights of w1 and w2
w1 -= learning_rate * grad_w1
w2 -= learning_rate * grad_w2结果：
pytorch实现：
import torch
#pytorch实现过程
N,D_in,H,D_out = 64,1000,100,10 #64个数，1000维的输入，100个隐层，10维输出
#把1000维降到10维输出
#随机创建一些训练数据
x = torch.randn(N,D_in)
y = torch.randn(N,D_out)
#降维
w1 = torch.randn(D_in,H)
w2 = torch.randn(H,D_out)
#学习率
learning_rate = 1e-6
for t in range(500):
#Forward
h = x.mm(w1) #N*H
h_relu = h.clamp(min=0)
y_pred = h_relu.mm(w2) #N*D_out
# compute loss
loss = (y_pred-y).pow(2).sum().item() #均方误差
print(t,loss)
#Backward pass
#compute the gradient
#求导
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 weights of w1 and w2
w1 -= learning_rate * grad_w1
w2 -= learning_rate * grad_w2结果：
PyTorch: Tensor和autograd
PyTorch的一个重要功能就是autograd，也就是说只要定义了forward pass(前向神经网络)，计算了loss之后，PyTorch可以自动求导计算模型所有参数的梯度。
一个PyTorch的Tensor表示计算图中的一个节点。如果x是一个Tensor并且x.requires_grad=True那么x.grad是另一个储存着x当前梯度(相对于一个scalar，常常是loss)的向量。
import torch
dtype = torch.float
device = torch.device("cpu")
# device = torch.device("cuda:0") # Uncomment this to run on GPU
# N 是 batch size; D_in 是 input dimension;
# H 是 hidden dimension; D_out 是 output dimension.
N, D_in, H, D_out = 64, 1000, 100, 10
# 创建随机的Tensor来保存输入和输出
# 设定requires_grad=False表示在反向传播的时候我们不需要计算gradient
x = torch.randn(N, D_in, device=device, dtype=dtype)
y = torch.randn(N, D_out, device=device, dtype=dtype)
# 创建随机的Tensor和权重。
# 设置requires_grad=True表示我们希望反向传播的时候计算Tensor的gradient
w1 = torch.randn(D_in, H, device=device, dtype=dtype, requires_grad=True)
w2 = torch.randn(H, D_out, device=device, dtype=dtype, requires_grad=True)
learning_rate = 1e-6
for t in range(500):
# 前向传播:通过Tensor预测y；这个和普通的神经网络的前向传播没有任何不同，
# 但是我们不需要保存网络的中间运算结果，因为我们不需要手动计算反向传播。
y_pred = x.mm(w1).clamp(min=0).mm(w2)
# 通过前向传播计算loss
# loss是一个形状为(1，)的Tensor
# loss.item()可以给我们返回一个loss的scalar
loss = (y_pred - y).pow(2).sum()
print(t, loss.item())
# PyTorch给我们提供了autograd的方法做反向传播。如果一个Tensor的requires_grad=True，
# backward会自动计算loss相对于每个Tensor的gradient。在backward之后，
# w1.grad和w2.grad会包含两个loss相对于两个Tensor的gradient信息。
loss.backward()
# 我们可以手动做gradient descent(后面我们会介绍自动的方法)。
# 用torch.no_grad()包含以下statements，因为w1和w2都是requires_grad=True，
# 但是在更新weights之后我们并不需要再做autograd。
# 另一种方法是在weight.data和weight.grad.data上做操作，这样就不会对grad产生影响。
# tensor.data会我们一个tensor，这个tensor和原来的tensor指向相同的内存空间，
# 但是不会记录计算图的历史。
with torch.no_grad():
w1 -= learning_rate * w1.grad
w2 -= learning_rate * w2.grad
# Manually zero the gradients after updating weights
w1.grad.zero_()
w2.grad.zero_()PyTorch: nn
这次我们使用PyTorch中nn这个库来构建网络。 用PyTorch autograd来构建计算图和计算gradients， 然后PyTorch会帮我们自动计算gradient
import torch
N,D_in,H,D_out = 64,1000,100,10
x = torch.randn(N,D_in)
y = torch.randn(N,D_out)
model = torch.nn.Sequential(
torch.nn.Linear(D_in,H), #w_1 * x+ b_1
torch.nn.ReLU(),
torch.nn.Linear(H,D_out),
)
#模型初始化两层
# torch.nn.init.normal_(model[0].weight)
# torch.nn.init.normal_(model[2].weight)
loss_fn = torch.nn.MSELoss(reduction="sum")
learing_rate = 1e-4
for it in range(500):
#Forward pass
y_pred = model(x)
#compute loss
loss = loss_fn(y_pred,y)
print(it,loss.item())
#清零grad否则会叠加
model.zero_grad()
#Backward pass
loss.backward()
#update weights of w1 and w2
with torch.no_grad():
for param in model.parameters():
param -= learing_rate * param.gradPyTorch: optim
这一次我们不再手动更新模型的weights,而是使用optim这个包来帮助我们更新参数。 optim这个package提供了各种不同的模型优化方法，包括SGD+momentum, RMSProp, Adam等等。
发现后面的精度越高损失的精度也会变小，初始化的模型加上效果会差，确实很玄学。
import torch
N,D_in,H,D_out = 64,1000,100,10
x = torch.randn(N,D_in)
y = torch.randn(N,D_out)
model = torch.nn.Sequential(
torch.nn.Linear(D_in,H), #w_1 * x+ b_1
torch.nn.ReLU(),
torch.nn.Linear(H,D_out),
)
#模型初始化两层
# torch.nn.init.normal_(model[0].weight)
# torch.nn.init.normal_(model[2].weight)
loss_fn = torch.nn.MSELoss(reduction="sum")
learing_rate = 0.000041111
#定义优化函数
optimizer = torch.optim.Adam(model.parameters(),lr=learing_rate)
for it in range(500):
#Forward pass
y_pred = model(x)
#compute loss
loss = loss_fn(y_pred,y)
print(it,loss.item())
#清零grad否则会叠加
optimizer.zero_grad()
#Backward pass
loss.backward()
#update weights of w1 and w2
optimizer.step()PyTorch: 自定义 nn Modules
我们可以定义一个模型，这个模型继承自nn.Module类。如果需要定义一个比Sequential模型更加复杂的模型，就需要定义nn.Module模型。
import torch
N,D_in,H,D_out = 64,1000,100,10
x = torch.randn(N,D_in)
y = torch.randn(N,D_out)
class TwoLayerNet(torch.nn.Module):
def __init__(self,D_in,H,D_out):
super(TwoLayerNet, self).__init__()#初始化
self.linear1 = torch.nn.Linear(D_in,H,bias=False)
self.linear2 = torch.nn.Linear(H,D_out,bias=False)
def forward(self,x):
y_pred = self.linear2(self.linear1(x).clamp(min=0))
return y_pred
model = TwoLayerNet(D_in,H,D_out)
loss_fn = torch.nn.MSELoss(reduction="sum")
learing_rate = 1e-4
#定义优化函数
optimizer = torch.optim.Adam(model.parameters(),lr=learing_rate)
for it in range(500):
#Forward pass
y_pred = model(x)
#compute loss
loss = loss_fn(y_pred,y)
print(it,loss.item())
#清零grad否则会叠加
optimizer.zero_grad()
#Backward pass
loss.backward()
#update weights of w1 and w2
optimizer.step()
6555
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
