Merge branch 'main' into splion-360/rl-qlearning-fixes

Author: AlannaBurke

advanced_source/dynamic_quantization_tutorial.py

@@ -134,10 +134,18 @@ def tokenize(self, path):
 # -----------------------------
 #
 # This is a tutorial on dynamic quantization, a quantization technique
-# that is applied after a model has been trained. Therefore, we'll simply load some
-# pretrained weights into this model architecture; these weights were obtained
-# by training for five epochs using the default settings in the word language model
-# example.
+# that is applied after a model has been trained. Therefore, we'll simply
+# load some pretrained weights into this model architecture; these
+# weights were obtained by training for five epochs using the default
+# settings in the word language model example.
+#
+# Before running this tutorial, download the required pre-trained model:
+#
+# .. code-block:: bash
+#
+#     wget https://s3.amazonaws.com/pytorch-tutorial-assets/word_language_model_quantize.pth
+#
+# Place the downloaded file in the data directory or update the model_data_filepath accordingly.
 
 ntokens = len(corpus.dictionary)
 

beginner_source/examples_autograd/polynomial_custom_function.py

@@ -33,8 +33,11 @@ def forward(ctx, input):
         """
         In the forward pass we receive a Tensor containing the input and return
         a Tensor containing the output. ctx is a context object that can be used
-        to stash information for backward computation. You can cache arbitrary
-        objects for use in the backward pass using the ctx.save_for_backward method.
+        to stash information for backward computation. You can cache tensors for
+        use in the backward pass using the ``ctx.save_for_backward`` method. Other
+        objects can be stored directly as attributes on the ctx object, such as
+        ``ctx.my_object = my_object``. Check out `Extending torch.autograd <https://docs.pytorch.org/docs/stable/notes/extending.html#extending-torch-autograd>`_
+        for further details.
         """
         ctx.save_for_backward(input)
         return 0.5 * (5 * input ** 3 - 3 * input)

beginner_source/introyt/introyt1_tutorial.py

@@ -303,22 +303,21 @@ def num_flat_features(self, x):
 #    The values passed to the transform are the means (first tuple) and the
 #    standard deviations (second tuple) of the rgb values of the images in
 #    the dataset. You can calculate these values yourself by running these
-#    few lines of code:
-#          ```
-#           from torch.utils.data import ConcatDataset
-#           transform = transforms.Compose([transforms.ToTensor()])
-#           trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
+#    few lines of code::
+#
+#        from torch.utils.data import ConcatDataset
+#        transform = transforms.Compose([transforms.ToTensor()])
+#        trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
 #                                        download=True, transform=transform)
 #
-#           #stack all train images together into a tensor of shape 
-#           #(50000, 3, 32, 32)
-#           x = torch.stack([sample[0] for sample in ConcatDataset([trainset])])
+#        # stack all train images together into a tensor of shape 
+#        # (50000, 3, 32, 32)
+#        x = torch.stack([sample[0] for sample in ConcatDataset([trainset])])
 #           
-#           #get the mean of each channel            
-#           mean = torch.mean(x, dim=(0,2,3)) #tensor([0.4914, 0.4822, 0.4465])
-#           std = torch.std(x, dim=(0,2,3)) #tensor([0.2470, 0.2435, 0.2616])  
-# 
-#          ```   
+#        # get the mean of each channel            
+#        mean = torch.mean(x, dim=(0,2,3)) # tensor([0.4914, 0.4822, 0.4465])
+#        std = torch.std(x, dim=(0,2,3)) # tensor([0.2470, 0.2435, 0.2616])  
+#    
 # 
 # There are many more transforms available, including cropping, centering,
 # rotation, and reflection.

intermediate_source/ddp_tutorial.rst

@@ -311,6 +311,7 @@ Let's still use the Toymodel example and create a file named ``elastic_ddp.py``.
 
 .. code:: python
 
+    import os
     import torch
     import torch.distributed as dist
     import torch.nn as nn

intermediate_source/flask_rest_api_tutorial.py

@@ -321,9 +321,7 @@ def get_prediction(image_bytes):
 #   for deploying a Flask server in production.
 #
 # - You can also add a UI by creating a page with a form which takes the image and
-#   displays the prediction. Check out the `demo <https://pytorch-imagenet.herokuapp.com/>`_
-#   of a similar project and its `source code <https://github.com/avinassh/pytorch-flask-api-heroku>`_.
-#
+#   displays the prediction. 
 # - In this tutorial, we only showed how to build a service that could return predictions for
 #   a single image at a time. We could modify our service to be able to return predictions for
 #   multiple images at once. In addition, the `service-streamer <https://github.com/ShannonAI/service-streamer>`_