模型搭建练习2_实现nn模块、optim、two_layer、dynamic_net

用variable实现nn.module

 import torch
 from torch.autograd import Variable

 N, D_in, H, D_out = 64, 1000, 100, 10

 x = Variable(torch.randn(N, D_in))
 y = Variable(torch.randn(N, D_out), requires_grad=False)

 model = torch.nn.Sequential(
     torch.nn.Linear(D_in, H),
     torch.nn.ReLU(),
     torch.nn.Linear(H, D_out),
 )

 loss_fn = torch.nn.MSELoss(size_average=False)

 learning_rate = 1e-4
 for t in range(2):
     # Forward pass
     y_pred = model(x)

     loss = loss_fn(y_pred, y)
     # Zero the gradients before running the backward pass.
     model.zero_grad()
     # Backward pass: compute gradient of the loss with respect to all the learnable
     # parameters of the model. Internally, the parameters of each Module are stored
     # in Variables with requires_grad=True, so this call will compute gradients for
     # all learnable parameters in the model.
     loss.backward()

     # Update the weights using gradient descent. Each parameter is a Variable
     for param in model.parameters():
         param.data -= learning_rate * param.grad.data

实现optim

 import torch
 from torch.autograd import Variable

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

 model = torch.nn.Sequential(
     torch.nn.Linear(D_in, H),
     torch.nn.ReLU(),
     torch.nn.Linear(H, D_out),
 )
 loss_fn = torch.nn.MSELoss(size_average=False)

 learning_rate = 1e-4
 # Use the optim package to define an Optimizer that will update the weights of
 # the model for us.
 optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
 for t in range(500):
     # Forward pass: compute predicted y by passing x to the model.
     y_pred = model(x)
     loss = loss_fn(y_pred, y)
     # Before the backward pass, use the optimizer object to zero all of the
     # gradients for the variables it will update (which are the learnable weights
     # of the model)
     optimizer.zero_grad()
     # Backward pass: compute gradient of the loss with respect to model
     # parameters
     loss.backward()
     # Calling the step function on an Optimizer makes an update to its
     # parameters
     optimizer.step()

实现two_layer模型

 import torch
 from torch.autograd import Variable

 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)
         self.linear2 = torch.nn.Linear(H, D_out)

     def forward(self, x):
         h_relu = self.linear1(x).clamp(min=0)
         y_pred = self.linear2(h_relu)
         return y_pred

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

 model = TwoLayerNet(D_in, H, D_out)
 criterion = torch.nn.MSELoss(size_average=False)
 optimizer = torch.optim.SGD(model.parameters(), lr=1e-4)
 for t in range(2):
     y_pred = model(x)
     loss = criterion(y_pred, y)
     optimizer.zero_grad()
     loss.backward()
     optimizer.step()

实现dynamic_net

 import random
 import torch
 from torch.autograd import Variable

 class DynamicNet(torch.nn.Module):
     def __init__(self, D_in, H, D_out):
         super(DynamicNet, self).__init__()
         self.input_linear = torch.nn.Linear(D_in, H)
         self.middle_linear = torch.nn.Linear(H, H)
         self.output_linear = torch.nn.Linear(H, D_out)

     def forward(self, x):
         h_relu = self.input_linear(x).clamp(min=0)
         for _ in range(random.randint(0, 3)):
             h_relu = self.middle_linear(h_relu).clamp(min=0)
         y_pred = self.output_linear(h_relu)
         return y_pred

 N, D_in, H, D_out = 64, 1000, 100, 10
 x = Variable(torch.randn(N, D_in))
 y = Variable(torch.randn(N, D_out), requires_grad=False)
 model = DynamicNet(D_in, H, D_out)

 criterion = torch.nn.MSELoss(size_average=False)
 optimizer = torch.optim.SGD(model.parameters(), lr=1e-4, momentum=0.9)
 for t in range(2):
     y_pred = model(x)
     loss = criterion(y_pred, y)
     optimizer.zero_grad()
     loss.backward()
     optimizer.step()