method 1
1 import torch 2 from torch.autograd import Variable 3 4 N, D_in, H, D_out = 64, 1000, 100, 10 5 x = Variable(torch.randn(N, D_in)) 6 y = Variable(torch.randn(N, D_out), requires_grad=False) 7 8 # define our model as a sequence of layers 9 model = torch.nn.Sequential( 10 torch.nn.Linear(D_in, H), 11 torch.nn.ReLU(), 12 torch.nn.Linear(H, D_out)) 13 # nn defines common loss functions 14 loss_fn = torch.nn.MSELoss(size_average=False) 15 16 learning_rate = 1e-4 17 18 for t in range(500): 19 # forward pass: feed data to model, and prediction to loss function 20 y_pred = model(x) 21 loss = loss_fn(y_pred, y) 22 23 # backward pass: compute all gradients 24 model.zero_grad() 25 loss.backward() 26 27 # make gradient step on each model parameter 28 for param in model.parameters(): 29 param.data -= learning_rate * param.grad.data
method 2
1 import torch 2 from torch.autograd import Variable 3 4 N, D_in, H, D_out = 64, 1000, 100, 10 5 x = Variable(torch.randn(N, D_in)) 6 y = Variable(torch.randn(N, D_out), requires_grad=False) 7 8 # define our model as a sequence of layers 9 model = torch.nn.Sequential( 10 torch.nn.Linear(D_in, H), 11 torch.nn.ReLU(), 12 torch.nn.Linear(H, D_out)) 13 # nn defines common loss functions 14 loss_fn = torch.nn.MSELoss(size_average=False) 15 16 learning_rate = 1e-4 17 # use an optimizer for different update rules 18 optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) 19 20 for t in range(500): 21 # forward pass: feed data to model, and prediction to loss function 22 y_pred = model(x) 23 loss = loss_fn(y_pred, y) 24 25 # backward pass: compute all gradients 26 model.zero_grad() 27 loss.backward() 28 29 # update all parameters after computing gradients 30 optimizer.step()
PyTorch nn Define new Modules
1 import torch 2 from torch.autograd import Variable 3 import torch.nn as nn 4 5 # define our whole model as a single Module 6 class TwoLayerNet(nn.Module): 7 # Initializer sets up two children (Modules can contain modules) 8 def _init_(self, D_in, H, D_out): 9 super(TwoLayerNet, self)._init_() 10 self.linear1 = torch.nn.Linear(D_in, H) 11 self.linear2 = torch.nn.Linear(H, D_out) 12 13 # Define forward pass using child modules and autograd ops on Variables 14 # No need to define backward - autograd will handle it 15 def forward(self, x): 16 h_relu = self.linear1(x).clamp(min=0) 17 y_pred = self.linear2(h_relu) 18 return y_pred 19 20 N, D_in, H, D_out = 64, 1000, 100, 10 21 x = Variable(torch.randn(N, D_in)) 22 y = Variable(torch.randn(N, D_out), requires_grad=False) 23 24 # Construct and train an instance of our model 25 model = TwoLayerNet(D_in, H, D_out) 26 27 criterion = torch.nn.MSELoss(size_average=False) 28 optimizer = torch.optim.SGD(model.parameters(), lr=1e-4) 29 for t in range(500): 30 y_pred = model(x) 31 loss = criterion(y_pred, y) 32 33 model.zero_grad() 34 loss.backward() 35 optimizer.step()