made beginner_source pep8 compliant

Author: euler16

beginner_source/blitz/autograd_tutorial.py

@@ -117,4 +117,5 @@
 ###############################################################
 # **Read Later:**
 #
-#   Documentation of ``Variable`` and ``Function`` is at http://pytorch.org/docs/autograd
+# Documentation of ``Variable`` and ``Function`` is at
+# http://pytorch.org/docs/autograd

beginner_source/blitz/cifar10_tutorial.py

@@ -87,11 +87,14 @@
 import numpy as np
 
 # functions to show an image
+
+
 def imshow(img):
     img = img / 2 + 0.5     # unnormalize
     npimg = img.numpy()
     plt.imshow(np.transpose(npimg, (1, 2, 0)))
 
+
 # get some random training images
 dataiter = iter(trainloader)
 images, labels = dataiter.next()
@@ -112,15 +115,16 @@ def imshow(img):
 import torch.nn as nn
 import torch.nn.functional as F
 
+
 class Net(nn.Module):
     def __init__(self):
         super(Net, self).__init__()
         self.conv1 = nn.Conv2d(3, 6, 5)
-        self.pool  = nn.MaxPool2d(2, 2)
+        self.pool = nn.MaxPool2d(2, 2)
         self.conv2 = nn.Conv2d(6, 16, 5)
-        self.fc1   = nn.Linear(16 * 5 * 5, 120)
-        self.fc2   = nn.Linear(120, 84)
-        self.fc3   = nn.Linear(84, 10)
+        self.fc1 = nn.Linear(16 * 5 * 5, 120)
+        self.fc2 = nn.Linear(120, 84)
+        self.fc3 = nn.Linear(84, 10)
 
     def forward(self, x):
         x = self.pool(F.relu(self.conv1(x)))
@@ -131,6 +135,7 @@ def forward(self, x):
         x = self.fc3(x)
         return x
 
+
 net = Net()
 
 ########################################################################
@@ -173,7 +178,8 @@ def forward(self, x):
         # print statistics
         running_loss += loss.data[0]
         if i % 2000 == 1999:    # print every 2000 mini-batches
-            print('[%d, %5d] loss: %.3f' % (epoch+1, i+1, running_loss / 2000))
+            print('[%d, %5d] loss: %.3f' %
+                  (epoch + 1, i + 1, running_loss / 2000))
             running_loss = 0.0
 
 print('Finished Training')

beginner_source/blitz/neural_networks_tutorial.py

@@ -47,16 +47,20 @@ class Net(nn.Module):
 
     def __init__(self):
         super(Net, self).__init__()
-        # 1 input image channel, 6 output channels, 5x5 square convolution kernel
+        # 1 input image channel, 6 output channels, 5x5 square convolution
+        # kernel
         self.conv1 = nn.Conv2d(1, 6, 5)
         self.conv2 = nn.Conv2d(6, 16, 5)
-        self.fc1   = nn.Linear(16 * 5 * 5, 120)  # an affine operation: y = Wx + b
-        self.fc2   = nn.Linear(120, 84)
-        self.fc3   = nn.Linear(84, 10)
+        # an affine operation: y = Wx + b
+        self.fc1 = nn.Linear(16 * 5 * 5, 120)
+        self.fc2 = nn.Linear(120, 84)
+        self.fc3 = nn.Linear(84, 10)
 
     def forward(self, x):
-        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))  # Max pooling over a (2, 2) window
-        x = F.max_pool2d(F.relu(self.conv2(x)), 2)  # If the size is a square you can only specify a single number
+        # Max pooling over a (2, 2) window
+        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
+        # If the size is a square you can only specify a single number
+        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
         x = x.view(-1, self.num_flat_features(x))
         x = F.relu(self.fc1(x))
         x = F.relu(self.fc2(x))
@@ -70,6 +74,7 @@ def num_flat_features(self, x):
             num_features *= s
         return num_features
 
+
 net = Net()
 print(net)
 
@@ -93,7 +98,8 @@ def num_flat_features(self, x):
 print(out)
 
 ########################################################################
-# Zero the gradient buffers of all parameters and backprops with random gradients:
+# Zero the gradient buffers of all parameters and backprops with random
+# gradients:
 net.zero_grad()
 out.backward(torch.randn(1, 10))
 
@@ -111,7 +117,7 @@ def num_flat_features(self, x):
 #     a fake batch dimension.
 #
 # Before proceeding further, let's recap all the classes you’ve seen so far.
-# 
+#
 # **Recap:**
 #   -  ``torch.Tensor`` - A *multi-dimensional array*.
 #   -  ``autograd.Variable`` - *Wraps a Tensor and records the history of
@@ -145,7 +151,7 @@ def num_flat_features(self, x):
 # There are several different
 # `loss functions <http://pytorch.org/docs/nn.html#loss-functions>`_ under the
 # nn package .
-# A simple loss is: ``nn.MSELoss`` which computes the mean-squared error 
+# A simple loss is: ``nn.MSELoss`` which computes the mean-squared error
 # between the input and the target.
 #
 # For example:

beginner_source/examples_autograd/tf_two_layer_net.py

@@ -60,18 +60,19 @@
 # Now we have built our computational graph, so we enter a TensorFlow session to
 # actually execute the graph.
 with tf.Session() as sess:
-  # Run the graph once to initialize the Variables w1 and w2.
-  sess.run(tf.global_variables_initializer())
+    # Run the graph once to initialize the Variables w1 and w2.
+    sess.run(tf.global_variables_initializer())
 
-  # Create numpy arrays holding the actual data for the inputs x and targets y
-  x_value = np.random.randn(N, D_in)
-  y_value = np.random.randn(N, D_out)
-  for _ in range(500):
-    # Execute the graph many times. Each time it executes we want to bind
-    # x_value to x and y_value to y, specified with the feed_dict argument.
-    # Each time we execute the graph we want to compute the values for loss,
-    # new_w1, and new_w2; the values of these Tensors are returned as numpy
-    # arrays.
-    loss_value, _, _ = sess.run([loss, new_w1, new_w2],
-                                feed_dict={x: x_value, y: y_value})
-    print(loss_value)
+    # Create numpy arrays holding the actual data for the inputs x and targets
+    # y
+    x_value = np.random.randn(N, D_in)
+    y_value = np.random.randn(N, D_out)
+    for _ in range(500):
+        # Execute the graph many times. Each time it executes we want to bind
+        # x_value to x and y_value to y, specified with the feed_dict argument.
+        # Each time we execute the graph we want to compute the values for loss,
+        # new_w1, and new_w2; the values of these Tensors are returned as numpy
+        # arrays.
+        loss_value, _, _ = sess.run([loss, new_w1, new_w2],
+                                    feed_dict={x: x_value, y: y_value})
+        print(loss_value)

beginner_source/examples_autograd/two_layer_net_autograd.py

@@ -42,31 +42,30 @@
 
 learning_rate = 1e-6
 for t in range(500):
-  # Forward pass: compute predicted y using operations on Variables; these
-  # are exactly the same operations we used to compute the forward pass using
-  # Tensors, but we do not need to keep references to intermediate values since
-  # we are not implementing the backward pass by hand.
-  y_pred = x.mm(w1).clamp(min=0).mm(w2)
+    # Forward pass: compute predicted y using operations on Variables; these
+    # are exactly the same operations we used to compute the forward pass using
+    # Tensors, but we do not need to keep references to intermediate values since
+    # we are not implementing the backward pass by hand.
+    y_pred = x.mm(w1).clamp(min=0).mm(w2)
 
-  # Compute and print loss using operations on Variables.
-  # Now loss is a Variable of shape (1,) and loss.data is a Tensor of shape
-  # (1,); loss.data[0] is a scalar value holding the loss.
-  loss = (y_pred - y).pow(2).sum()
-  print(t, loss.data[0])
+    # Compute and print loss using operations on Variables.
+    # Now loss is a Variable of shape (1,) and loss.data is a Tensor of shape
+    # (1,); loss.data[0] is a scalar value holding the loss.
+    loss = (y_pred - y).pow(2).sum()
+    print(t, loss.data[0])
 
-  # Use autograd to compute the backward pass. This call will compute the
-  # gradient of loss with respect to all Variables with requires_grad=True.
-  # After this call w1.grad and w2.grad will be Variables holding the gradient
-  # of the loss with respect to w1 and w2 respectively.
-  loss.backward()
+    # Use autograd to compute the backward pass. This call will compute the
+    # gradient of loss with respect to all Variables with requires_grad=True.
+    # After this call w1.grad and w2.grad will be Variables holding the gradient
+    # of the loss with respect to w1 and w2 respectively.
+    loss.backward()
 
-  # Update weights using gradient descent; w1.data and w2.data are Tensors,
-  # w1.grad and w2.grad are Variables and w1.grad.data and w2.grad.data are
-  # Tensors.
-  w1.data -= learning_rate * w1.grad.data
-  w2.data -= learning_rate * w2.grad.data
-
-  # Manually zero the gradients after updating weights
-  w1.grad.data.zero_()
-  w2.grad.data.zero_()
+    # Update weights using gradient descent; w1.data and w2.data are Tensors,
+    # w1.grad and w2.grad are Variables and w1.grad.data and w2.grad.data are
+    # Tensors.
+    w1.data -= learning_rate * w1.grad.data
+    w2.data -= learning_rate * w2.grad.data
 
+    # Manually zero the gradients after updating weights
+    w1.grad.data.zero_()
+    w2.grad.data.zero_()

beginner_source/examples_autograd/two_layer_net_custom_function.py

@@ -15,31 +15,33 @@
 import torch
 from torch.autograd import Variable
 
+
 class MyReLU(torch.autograd.Function):
-  """
-  We can implement our own custom autograd Functions by subclassing
-  torch.autograd.Function and implementing the forward and backward passes
-  which operate on Tensors.
-  """
-  def forward(self, input):
     """
-    In the forward pass we receive a Tensor containing the input and return a
-    Tensor containing the output. You can cache arbitrary Tensors for use in the
-    backward pass using the save_for_backward method.
+    We can implement our own custom autograd Functions by subclassing
+    torch.autograd.Function and implementing the forward and backward passes
+    which operate on Tensors.
     """
-    self.save_for_backward(input)
-    return input.clamp(min=0)
 
-  def backward(self, grad_output):
-    """
-    In the backward pass we receive a Tensor containing the gradient of the loss
-    with respect to the output, and we need to compute the gradient of the loss
-    with respect to the input.
-    """
-    input, = self.saved_tensors
-    grad_input = grad_output.clone()
-    grad_input[input < 0] = 0
-    return grad_input
+    def forward(self, input):
+        """
+        In the forward pass we receive a Tensor containing the input and return a
+        Tensor containing the output. You can cache arbitrary Tensors for use in the
+        backward pass using the save_for_backward method.
+        """
+        self.save_for_backward(input)
+        return input.clamp(min=0)
+
+    def backward(self, grad_output):
+        """
+        In the backward pass we receive a Tensor containing the gradient of the loss
+        with respect to the output, and we need to compute the gradient of the loss
+        with respect to the input.
+        """
+        input, = self.saved_tensors
+        grad_input = grad_output.clone()
+        grad_input[input < 0] = 0
+        return grad_input
 
 
 dtype = torch.FloatTensor
@@ -59,25 +61,24 @@ def backward(self, grad_output):
 
 learning_rate = 1e-6
 for t in range(500):
-  # Construct an instance of our MyReLU class to use in our network
-  relu = MyReLU()
-
-  # Forward pass: compute predicted y using operations on Variables; we compute
-  # ReLU using our custom autograd operation.
-  y_pred = relu(x.mm(w1)).mm(w2)
+    # Construct an instance of our MyReLU class to use in our network
+    relu = MyReLU()
 
-  # Compute and print loss
-  loss = (y_pred - y).pow(2).sum()
-  print(t, loss.data[0])
+    # Forward pass: compute predicted y using operations on Variables; we compute
+    # ReLU using our custom autograd operation.
+    y_pred = relu(x.mm(w1)).mm(w2)
 
-  # Use autograd to compute the backward pass.
-  loss.backward()
+    # Compute and print loss
+    loss = (y_pred - y).pow(2).sum()
+    print(t, loss.data[0])
 
-  # Update weights using gradient descent
-  w1.data -= learning_rate * w1.grad.data
-  w2.data -= learning_rate * w2.grad.data
+    # Use autograd to compute the backward pass.
+    loss.backward()
 
-  # Manually zero the gradients after updating weights
-  w1.grad.data.zero_()
-  w2.grad.data.zero_()
+    # Update weights using gradient descent
+    w1.data -= learning_rate * w1.grad.data
+    w2.data -= learning_rate * w2.grad.data
 
+    # Manually zero the gradients after updating weights
+    w1.grad.data.zero_()
+    w2.grad.data.zero_()

beginner_source/examples_nn/dynamic_net.py

@@ -12,36 +12,37 @@
 import torch
 from torch.autograd import Variable
 
+
 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 __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.
+    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.
+        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
+        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;
@@ -60,14 +61,14 @@ def forward(self, x):
 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)
+    # 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])
+    # 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()
+    # Zero gradients, perform a backward pass, and update the weights.
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()