Make misc improvements to quickstart (#43)

Author: shwars

beginner_source/quickstart/autograd_tutorial.py

@@ -19,6 +19,7 @@
 """
 
 import torch
+
 x = torch.ones(5)  # input tensor
 y = torch.zeros(3)  # expected output
 w = torch.randn(5, 3, requires_grad=True)
@@ -55,7 +56,8 @@
 # documentation <https://pytorch.org/docs/stable/autograd.html#function>`__.
 #
 
-print(z.grad_fn, loss.grad_fn, sep='\n')
+print('Gradient function for z =',z.grad_fn)
+print('Gradient function for loss =', loss.grad_fn)
 
 ######################################################################
 # Computing Gradients
@@ -152,8 +154,9 @@
 #
 
 x = torch.zeros(2, requires_grad=True)
-def f(x): return (x-torch.tensor([3, -2])).pow(2).sum()
 
+def f(x):
+    return (x-torch.tensor([3, -2])).pow(2).sum()
 
 lr = 0.1
 

beginner_source/quickstart/dataquickstart_tutorial.py

@@ -23,7 +23,7 @@
 # 
 # If not properly organized, code for processing data samples can quickly get messy and become hard to maintain. Since different model architectures can be applied to many data types, we ideally want our dataset code to be decoupled from our model training code. To this end, PyTorch provides a simple Datasets interface for linking managing collections of data. 
 # 
-# A whole set of example datasets such as Fashion MNIST that implement this interface are built into PyTorch extension libraries. They are subclasses of torch.utils.data.Dataset that have parameters and functions specific to the type of data and the particular dataset. The actual data samples can be downloaded from the internet.These are useful for benchmarking and testing your models before training on your own custom datasets.
+# A whole set of example datasets such as Fashion MNIST that implement this interface are built into PyTorch extension libraries. They are subclasses of `torch.utils.data.Dataset` that have parameters and functions specific to the type of data and the particular dataset. The actual data samples can be downloaded from the internet. These are useful for benchmarking and testing your models before training on your own custom datasets.
 # 
 # You can find some of them below. 
 #
@@ -36,7 +36,7 @@
 # Iterating through a Dataset
 # -----------------
 # 
-# Once we have a Dataset we can index it manually like a list `clothing[index]`. 
+# Once we have a Dataset ``ds``, we can index it manually like a list: ``ds[index]``. 
 # 
 # Here is an example of how to load the `Fashion-MNIST <https://research.zalando.com/welcome/mission/research-projects/fashion-mnist/>`_ dataset from torch vision.
 # `Fashion-MNIST <https://research.zalando.com/welcome/mission/research-projects/fashion-mnist/>`_ is a dataset of Zalando’s article images consisting of of 60,000 training examples and 10,000 test examples. 
@@ -60,23 +60,24 @@
 cols, rows = 3, 3
 for i in range(1, cols*rows +1):
     sample_idx = np.random.randint(len(clothing))
-    img = clothing[sample_idx][0][0,:,:]
+    img = clothing[sample_idx][0]
     figure.add_subplot(rows, cols, i)
     plt.title(labels_map[clothing[sample_idx][1]])
     plt.axis('off')
     plt.imshow(img, cmap='gray')
 plt.show()
 
 #################################################################
-# .. figure:: /_static/img/quickstart/fashion_mnist.png
+# ..
+#  .. figure:: /_static/img/quickstart/fashion_mnist.png
 #    :alt: fashion_mnist
 #
 
 #################################################################
 # Creating a Custom Dataset
 # -----------------
 #
-# To work with your own data lets look at the a simple custom image Dataset implementation:
+# To work with your own data, we need to implement a custom class that inherits from  ``Dataset```. Let's look at a custom image dataset implementation. In this example, we have a number of images stored in a directory, and their labels stored separately in CSV annotation file.
 #
 
 import os
@@ -114,7 +115,7 @@ def __getitem__(self, idx):
 # Imports 
 # -------
 # 
-# Import os for file handling, torch for PyTorch, `pandas <https://pandas.pydata.org/>`_ for loading labels, `torch vision <https://pytorch.org/blog/pytorch-1.7-released/>`_ to read image files, and Dataset to implement the Dataset interface.
+# Import `os` for file handling, torch for PyTorch, `pandas <https://pandas.pydata.org/>`_ for loading labels, `torch vision <https://pytorch.org/blog/pytorch-1.7-released/>`_ to read image files, and Dataset to implement the Dataset interface.
 # 
 # Example:
 #
@@ -130,16 +131,13 @@ def __getitem__(self, idx):
 # Init
 # -----------------
 #
-# The init function is used for all the first time operations when our Dataset is loaded. In this case we use it to load our annotation labels to memory and the keep track of directory of our image file. Note that different types of data can take different init inputs you are not limited to just an annotations file, directory_path and transforms but for images this is a standard practice.
-# A sample csv annotations file may look as follows:
-#
-# tshirt1.jpg, 0
-#
-# tshirt2.jpg, 0
+# The init function is used for all the first time operations when our Dataset is loaded. In this case we use it to load our annotation labels to memory and the keep track of directory of our image file. Note that different types of data can take different init inputs. You are not limited to just an annotations file, directory path and transforms, but for images this is a standard practice.
+# A sample csv annotations file may look as follows: ::
 #
+#     tshirt1.jpg, 0
+#     tshirt2.jpg, 0
 #     ......
-#
-# ankleboot999.jpg, 9
+#     ankleboot999.jpg, 9
 # 
 # Example:
 # 
@@ -153,7 +151,7 @@ def __init__(self, annotations_file, img_dir, transform=None):
 # __len__
 # -----------------
 #
-# The __len__ function is very simple here we just need to return the number of samples in our dataset. 
+# The __len__ function is very simple, we just need to return the number of samples in our dataset. 
 # 
 # Example:
 
@@ -164,9 +162,9 @@ def __len__(self):
 # __getitem__
 # -----------------
 #
-# The __getitem__ function is the most important function in the Datasets interface this. It takes a tensor or an index as input and returns a loaded sample from you dataset at from the given indecies.
+# The __getitem__ function is the most important function in the Datasets interface. It takes a tensor or an index as input and returns a loaded sample from you dataset at the given indices.
 # 
-# In this sample if provided a tensor we convert the tensor to a list containing our index. We then load the file at the given index from our image directory as well as the image label from our pandas annotations DataFrame. This image and label are then wrapped in a single sample dictionary which we can apply a Transform on and return. To learn more about Transforms see the next section of the Blitz. 
+# If provided a tensor as an index, we convert the tensor to a list first. We then load the file at the given index from our image directory, as well as the image label from our pandas annotations DataFrame. This image and label are then wrapped in a single sample dictionary which we can apply a Transform on and return. To learn more about Transforms see the next section of the Blitz. 
 # 
 # Example:
 #
@@ -190,16 +188,17 @@ def __getitem__(self, idx):
 # Now we have a organized mechansim for managing data which is great, but there is still a lot of manual work we would have to do train a model with our Dataset. 
 # 
 # For example we would have to manually maintain the code for: 
+#
 # * Batching 
 # * Suffling 
 # * Parallel batch distribution 
 # 
-# The PyTorch Dataloader *torch.utils.data.DataLoader* is an iterator that handles all of this complexity for us enabling us to load a dataset and focusing on train our model.
+# The PyTorch Dataloader ``torch.utils.data.DataLoader`` is an iterator that handles all of this complexity for us, enabling us to load a dataset and focus on training our model.
 
 dataloader = DataLoader(clothing, batch_size=4, shuffle=True, num_workers=0)
 
 #################################################################
-# With this we have all we need to know to load an process data of any kind in PyTorch to train deep learning models.
+# With this we have all we need to know to load and process data of any kind in PyTorch to train deep learning models.
 # 
 # Next: Learn more about how to `transform that data for training <transforms_tutorial.html>`_.
 #

beginner_source/quickstart/tensor_tutorial.py

@@ -8,9 +8,9 @@
 similar to **NumPy array**, and supports similar operations. However,
 there are two very important features of Torch tensors that make them
 especially useful for training large-scale neural networks:
--  Tensor operations can be performed on GPUs or other specialized hardware to accelerate computing
--  Tensor operations support automatic differentiation using
-   `pytorch.autograd engine <autograd_tutorial.html>`__
+
+ *  Tensor operations can be performed on GPUs or other specialized hardware to accelerate computing
+ *  Tensor operations support automatic differentiation using `pytorch.autograd engine <autograd_tutorial.html>`__
 Conversion between Torch tensors and NumPy arrays can be done easily:
 """
 
@@ -178,9 +178,9 @@
 # using different dimensions:
 #
 
-print(x.size())  # original size of x is 3x5
-print(x.view(5, 3, 1).size())  # will give size 5x3x1
-print(x.view(5, -1))  # will result in size 5x3
+print('Original size of x =',x.size())  # original size of x is 3x5
+print('Size after reshaping is',x.view(5, 3, 1).size())  # will give size 5x3x1
+print('Reshaped tensor:\n',x.view(5, -1))  # will result in size 5x3
 
 
 ######################################################################
@@ -205,7 +205,9 @@
 #
 
 print(x.size())  # original size of x is 3x5
-print(x[0].size(), x[:, 0].size(), x[..., 1].size())  # will give 5, 3, 3
+print('First row: ',x[0])
+print('First column: ', x[:, 0])
+print('Last column:', x[..., -1])
 
 
 ######################################################################
@@ -215,7 +217,7 @@
 #
 
 val = x.sum().item()  # will compute the sum of all elements
-
+print(val)
 
 ######################################################################
 # Hardware-Accelerated Computations
@@ -241,7 +243,6 @@
 y = torch.ones_like(x)  # create tensor on CPU
 y = y.to(device)  # move tensor to another device
 z = x+y  # this is performed on GPU if it is available
-print(z)
 print(z.to("cpu", torch.double))