Merge branch 'master' into add-youtube-tutorials

Author: brianjo

_static/torchvision_finetuning_instance_segmentation.ipynb

@@ -1448,7 +1448,7 @@
         "        self.masks = list(sorted(os.listdir(os.path.join(root, \"PedMasks\"))))\n",
         "\n",
         "    def __getitem__(self, idx):\n",
-        "        # load images ad masks\n",
+        "        # load images and masks\n",
         "        img_path = os.path.join(self.root, \"PNGImages\", self.imgs[idx])\n",
         "        mask_path = os.path.join(self.root, \"PedMasks\", self.masks[idx])\n",
         "        img = Image.open(img_path).convert(\"RGB\")\n",

_static/tv-training-code.py

@@ -25,7 +25,7 @@ def __init__(self, root, transforms):
         self.masks = list(sorted(os.listdir(os.path.join(root, "PedMasks"))))
 
     def __getitem__(self, idx):
-        # load images ad masks
+        # load images and masks
         img_path = os.path.join(self.root, "PNGImages", self.imgs[idx])
         mask_path = os.path.join(self.root, "PedMasks", self.masks[idx])
         img = Image.open(img_path).convert("RGB")

beginner_source/basics/quickstart_tutorial.py

@@ -83,7 +83,7 @@
 # Creating Models
 # ------------------
 # To define a neural network in PyTorch, we create a class that inherits 
-# from `nn.Module <https://pytorch.org/docs/stable/generated/torch.nn.Module.html)>`_. We define the layers of the network
+# from `nn.Module <https://pytorch.org/docs/stable/generated/torch.nn.Module.html>`_. We define the layers of the network
 # in the ``__init__`` function and specify how data will pass through the network in the ``forward`` function. To accelerate 
 # operations in the neural network, we move it to the GPU if available.
 

beginner_source/blitz/autograd_tutorial.py

@@ -299,7 +299,7 @@
 # The only parameters that compute gradients are the weights and bias of ``model.fc``.
 
 # Optimize only the classifier
-optimizer = optim.SGD(model.fc.parameters(), lr=1e-2, momentum=0.9)
+optimizer = optim.SGD(model.parameters(), lr=1e-2, momentum=0.9)
 
 ##########################################################################
 # Notice although we register all the parameters in the optimizer,

beginner_source/blitz/neural_networks_tutorial.py

@@ -7,7 +7,7 @@
 
 Now that you had a glimpse of ``autograd``, ``nn`` depends on
 ``autograd`` to define models and differentiate them.
-An ``nn.Module`` contains layers, and a method ``forward(input)``\ that
+An ``nn.Module`` contains layers, and a method ``forward(input)`` that
 returns the ``output``.
 
 For example, look at this network that classifies digit images:

intermediate_source/seq2seq_translation_tutorial.py

@@ -76,17 +76,6 @@
 helpful as those concepts are very similar to the Encoder and Decoder
 models, respectively.
 
-And for more, read the papers that introduced these topics:
-
--  `Learning Phrase Representations using RNN Encoder-Decoder for
-   Statistical Machine Translation <https://arxiv.org/abs/1406.1078>`__
--  `Sequence to Sequence Learning with Neural
-   Networks <https://arxiv.org/abs/1409.3215>`__
--  `Neural Machine Translation by Jointly Learning to Align and
-   Translate <https://arxiv.org/abs/1409.0473>`__
--  `A Neural Conversational Model <https://arxiv.org/abs/1506.05869>`__
-
-
 **Requirements**
 """
 from __future__ import unicode_literals, print_function, division

intermediate_source/torchvision_tutorial.rst

@@ -122,7 +122,7 @@ Let’s write a ``torch.utils.data.Dataset`` class for this dataset.
            self.masks = list(sorted(os.listdir(os.path.join(root, "PedMasks"))))
 
        def __getitem__(self, idx):
-           # load images ad masks
+           # load images and masks
            img_path = os.path.join(self.root, "PNGImages", self.imgs[idx])
            mask_path = os.path.join(self.root, "PedMasks", self.masks[idx])
            img = Image.open(img_path).convert("RGB")

prototype_source/fx_graph_mode_ptq_static.rst

@@ -311,6 +311,7 @@ The purpose for calibration is to run through some sample examples that is repre
 the statistics of the Tensors and we can later use this information to calculate quantization parameters. 
 
 .. code:: python
+
     def calibrate(model, data_loader):  
         model.eval()    
         with torch.no_grad():   
@@ -320,17 +321,19 @@ the statistics of the Tensors and we can later use this information to calculate
 
 7. Convert the Model to a Quantized Model 
 ----------------------------------------- 
-``convert_fx`` takes a calibrated model and produces a quantized model.   
+``convert_fx`` takes a calibrated model and produces a quantized model.
 
 .. code:: python
-    quantized_model = convert_fx(prepared_model)    
+
+    quantized_model = convert_fx(prepared_model)
     print(quantized_model)
-   
+
 8. Evaluation 
 ------------- 
 We can now print the size and accuracy of the quantized model.    
 
 .. code:: python
+
     print("Size of model before quantization")  
     print_size_of_model(float_model)    
     print("Size of model after quantization")   
@@ -372,6 +375,7 @@ we'll first call fuse explicitly to fuse the conv and bn in the model:
 Note that ``fuse_fx`` only works in eval mode.    
 
 .. code:: python
+
     fused = fuse_fx(float_model)    
 
     conv1_weight_after_fuse = fused.conv1[0].weight[0]  
@@ -383,6 +387,7 @@ Note that ``fuse_fx`` only works in eval mode.
 --------------------------------------------------------------------   
 
 .. code:: python
+
     scripted_float_model_file = "resnet18_scripted.pth" 
 
     print("Size of baseline model") 
@@ -397,6 +402,7 @@ quantized in eager mode. FX graph mode and eager mode produce very similar quant
 so the expectation is that the accuracy and speedup are similar as well.  
 
 .. code:: python
+
     print("Size of Fx graph mode quantized model")  
     print_size_of_model(quantized_model)    
     top1, top5 = evaluate(quantized_model, criterion, data_loader_test)