add comments for nn examples

Author: jcjohnson

new_function.py

@@ -0,0 +1,71 @@
+import random
+import torch
+from torch.autograd import Variable
+
+"""
+To showcase the power of PyTorch dynamic graphs, we will implement a very strange
+model: a fully-connected ReLU network that on each forward pass randomly chooses
+a number between 1 and 4 and has that many hidden layers, reusing the same
+weights multiple times to compute the innermost hidden layers.
+"""
+
+class DynamicNet(torch.nn.Module):
+  def __init__(self, D_in, H, D_out):
+    """
+    In the constructor we construct three nn.Linear instances that we will use
+    in the forward pass.
+    """
+    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):
+    """
+    For the forward pass of the model, we randomly choose either 0, 1, 2, or 3
+    and reuse the middle_linear Module that many times to compute hidden layer
+    representations.
+
+    Since each forward pass builds a dynamic computation graph, we can use normal
+    Python control-flow operators like loops or conditional statements when
+    defining the forward pass of the model.
+
+    Here we also see that it is perfectly safe to reuse the same Module many
+    times when defining a computational graph. This is a big improvement from Lua
+    Torch, where each Module could be used only once.
+    """
+    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 is batch size; D_in is input dimension;
+# H is hidden dimension; D_out is output dimension.
+N, D_in, H, D_out = 64, 1000, 100, 10
+
+# Create random Tensors to hold inputs and outputs, and wrap them in Variables
+x = Variable(torch.randn(N, D_in))
+y = Variable(torch.randn(N, D_out), requires_grad=False)
+
+# Construct our model by instantiating the class defined above
+model = DynamicNet(D_in, H, D_out)
+
+# Construct our loss function and an Optimizer. Training this strange model with
+# vanilla stochastic gradient descent is tough, so we use momentum
+criterion = torch.nn.MSELoss(size_average=False)
+optimizer = torch.optim.SGD(model.parameters(), lr=1e-4, momentum=0.9)
+for t in range(500):
+  # Forward pass: Compute predicted y by passing x to the model
+  y_pred = model(x)
+
+  # Compute and print loss
+  loss = criterion(y_pred, y)
+  print(t, loss.data[0])
+
+  # Zero gradients, perform a backward pass, and update the weights.
+  optimizer.zero_grad()
+  loss.backward()
+  optimizer.step()
+

nn/dynamic_net.py

@@ -0,0 +1,62 @@
+import torch
+from torch.autograd import Variable
+
+"""
+A fully-connected ReLU network with one hidden layer, trained to predict y from x
+by minimizing squared Euclidean distance.
+
+This implementation defines the model as a custom Module subclass. Whenever you
+want a model more complex than a simple sequence of existing Modules you will
+need to define your model this way.
+"""
+
+class TwoLayerNet(torch.nn.Module):
+  def __init__(self, D_in, H, D_out):
+    """
+    In the constructor we instantiate two nn.Linear modules and assign them as
+    member variables.
+    """
+    super(TwoLayerNet, self).__init__()
+    self.linear1 = torch.nn.Linear(D_in, H)
+    self.linear2 = torch.nn.Linear(H, D_out)
+
+  def forward(self, x):
+    """
+    In the forward function we accept a Variable of input data and we must return
+    a Variable of output data. We can use Modules defined in the constructor as
+    well as arbitrary operators on Variables.
+    """
+    h_relu = self.linear1(x).clamp(min=0)
+    y_pred = self.linear2(h_relu)
+    return y_pred
+
+
+# N is batch size; D_in is input dimension;
+# H is hidden dimension; D_out is output dimension.
+N, D_in, H, D_out = 64, 1000, 100, 10
+
+# Create random Tensors to hold inputs and outputs, and wrap them in Variables
+x = Variable(torch.randn(N, D_in))
+y = Variable(torch.randn(N, D_out), requires_grad=False)
+
+# Construct our model by instantiating the class defined above
+model = TwoLayerNet(D_in, H, D_out)
+
+# Construct our loss function and an Optimizer. The call to model.parameters()
+# in the SGD constructor will contain the learnable parameters of the two
+# nn.Linear modules which are members of the model.
+criterion = torch.nn.MSELoss(size_average=False)
+optimizer = torch.optim.SGD(model.parameters(), lr=1e-4)
+for t in range(500):
+  # Forward pass: Compute predicted y by passing x to the model
+  y_pred = model(x)
+
+  # Compute and print loss
+  loss = criterion(y_pred, y)
+  print(t, loss.data[0])
+
+  # Zero gradients, perform a backward pass, and update the weights.
+  optimizer.zero_grad()
+  loss.backward()
+  optimizer.step()
+

nn/two_layer_net_module.py

@@ -0,0 +1,62 @@
+import torch
+from torch.autograd import Variable
+
+
+"""
+A fully-connected ReLU network with one hidden layer, trained to predict y from x
+by minimizing squared Euclidean distance.
+
+This implementation uses the nn package from PyTorch to build the network.
+PyTorch autograd makes it easy to define computational graphs and take gradients,
+but raw autograd can be a bit too low-level for defining complex neural networks;
+this is where the nn package can help. The nn package defines a set of Modules,
+which you can think of as a neural network layer that has produces output from
+input and may have some trainable weights.
+"""
+
+# N is batch size; D_in is input dimension;
+# H is hidden dimension; D_out is output dimension.
+N, D_in, H, D_out = 64, 1000, 100, 10
+
+# Create random Tensors to hold inputs and outputs, and wrap them in Variables.
+x = Variable(torch.randn(N, D_in))
+y = Variable(torch.randn(N, D_out), requires_grad=False)
+
+# Use the nn package to define our model as a sequence of layers. Each Linear
+# module has its own weight and bias.
+model = torch.nn.Sequential(
+          torch.nn.Linear(D_in, H),
+          torch.nn.ReLU(),
+          torch.nn.Linear(H, D_out),
+        )
+
+# The nn package also contains definitions of popular loss functions; in this
+# case we will use Mean Squared Error (MSE) as our loss function.
+loss_fn = torch.nn.MSELoss(size_average=False)
+
+learning_rate = 1e-4
+for t in range(500):
+  # Forward pass: compute predicted y by passing x to the model. Module objects
+  # override the __call__ operator so you can call them like functions. When
+  # doing so you pass a Variable of input data to the Module and it produces
+  # a Variable of output data.
+  y_pred = model(x)
+
+  # Compute and print loss. We pass Variables containing the predicted and true
+  # values of y, and the loss function returns a Variable containing the loss.
+  loss = loss_fn(y_pred, y)
+  print(t, loss.data[0])
+  
+  # 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, so
+  # we can access its data and gradients like we did before.
+  for param in model.parameters():
+    param.data -= learning_rate * param.grad.data

nn/two_layer_net_nn.py

@@ -0,0 +1,57 @@
+import torch
+from torch.autograd import Variable
+
+
+"""
+A fully-connected ReLU network with one hidden layer, trained to predict y from x
+by minimizing squared Euclidean distance.
+
+This implementation uses the nn package from PyTorch to build the network.
+
+Rather than manually updating the weights of the model as we have been doing,
+we use the optim package to define an Optimizer that will update the weights
+for us. The optim package defines many optimization algorithms that are commonly
+used for deep learning, including SGD+momentum, RMSProp, Adam, etc.
+"""
+
+# N is batch size; D_in is input dimension;
+# H is hidden dimension; D_out is output dimension.
+N, D_in, H, D_out = 64, 1000, 100, 10
+
+# Create random Tensors to hold inputs and outputs, and wrap them in Variables.
+x = Variable(torch.randn(N, D_in))
+y = Variable(torch.randn(N, D_out), requires_grad=False)
+
+# Use the nn package to define our model and loss function.
+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)
+
+# Use the optim package to define an Optimizer that will update the weights of
+# the model for us. Here we will use stochastic gradient descent (SGD), but the
+# optim package contains many other optimization algoriths. The first argument
+# to the SGD constructor tells the optimizer which Variables it should update.
+learning_rate = 1e-4
+optimizer = torch.optim.SGD(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)
+
+  # Compute and print loss.
+  loss = loss_fn(y_pred, y)
+  print(t, loss.data[0])
+  
+  # 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()
+