Merge branch 'main' into add_amx_doc

Author: CaoE

advanced_source/rpc_ddp_tutorial.rst

@@ -1,6 +1,6 @@
 Combining Distributed DataParallel with Distributed RPC Framework
 =================================================================
-**Authors**: `Pritam Damania <https://github.com/pritamdamania87>`_ and `Yi Wang <https://github.com/SciPioneer>`_
+**Authors**: `Pritam Damania <https://github.com/pritamdamania87>`_ and `Yi Wang <https://github.com/wayi1>`_
 
 .. note::
    |edit| View and edit this tutorial in `github <https://github.com/pytorch/tutorials/blob/main/advanced_source/rpc_ddp_tutorial.rst>`__.

beginner_source/fgsm_tutorial.py

@@ -98,13 +98,6 @@
 import numpy as np
 import matplotlib.pyplot as plt
 
-# NOTE: This is a hack to get around "User-agent" limitations when downloading MNIST datasets
-#       see, https://github.com/pytorch/vision/issues/3497 for more information
-from six.moves import urllib
-opener = urllib.request.build_opener()
-opener.addheaders = [('User-agent', 'Mozilla/5.0')]
-urllib.request.install_opener(opener)
-
 
 ######################################################################
 # Implementation
@@ -140,6 +133,8 @@
 epsilons = [0, .05, .1, .15, .2, .25, .3]
 pretrained_model = "data/lenet_mnist_model.pth"
 use_cuda=True
+# Set random seed for reproducibility
+torch.manual_seed(42)
 
 
 ######################################################################
@@ -178,18 +173,18 @@ def forward(self, x):
 test_loader = torch.utils.data.DataLoader(
     datasets.MNIST('../data', train=False, download=True, transform=transforms.Compose([
             transforms.ToTensor(),
-            ])), 
+            ])),
         batch_size=1, shuffle=True)
 
 # Define what device we are using
 print("CUDA Available: ",torch.cuda.is_available())
-device = torch.device("cuda" if (use_cuda and torch.cuda.is_available()) else "cpu")
+device = torch.device("cuda" if use_cuda and torch.cuda.is_available() else "cpu")
 
 # Initialize the network
 model = Net().to(device)
 
 # Load the pretrained model
-model.load_state_dict(torch.load(pretrained_model, map_location='cpu'))
+model.load_state_dict(torch.load(pretrained_model, weights_only=True, map_location='cpu'))
 
 # Set the model in evaluation mode. In this case this is for the Dropout layers
 model.eval()
@@ -289,7 +284,7 @@ def test( model, device, test_loader, epsilon ):
         if final_pred.item() == target.item():
             correct += 1
             # Special case for saving 0 epsilon examples
-            if (epsilon == 0) and (len(adv_examples) < 5):
+            if epsilon == 0 and len(adv_examples) < 5:
                 adv_ex = perturbed_data.squeeze().detach().cpu().numpy()
                 adv_examples.append( (init_pred.item(), final_pred.item(), adv_ex) )
         else:
@@ -300,7 +295,7 @@ def test( model, device, test_loader, epsilon ):
 
     # Calculate final accuracy for this epsilon
     final_acc = correct/float(len(test_loader))
-    print("Epsilon: {}\tTest Accuracy = {} / {} = {}".format(epsilon, correct, len(test_loader), final_acc))
+    print(f"Epsilon: {epsilon}\tTest Accuracy = {correct} / {len(test_loader)} = {final_acc}")
 
     # Return the accuracy and an adversarial example
     return final_acc, adv_examples
@@ -386,9 +381,9 @@ def test( model, device, test_loader, epsilon ):
         plt.xticks([], [])
         plt.yticks([], [])
         if j == 0:
-            plt.ylabel("Eps: {}".format(epsilons[i]), fontsize=14)
+            plt.ylabel(f"Eps: {epsilons[i]}", fontsize=14)
         orig,adv,ex = examples[i][j]
-        plt.title("{} -> {}".format(orig, adv))
+        plt.title(f"{orig} -> {adv}")
         plt.imshow(ex, cmap="gray")
 plt.tight_layout()
 plt.show()

intermediate_source/dynamic_quantization_bert_tutorial.rst

@@ -253,8 +253,6 @@ model before and after the dynamic quantization.
         torch.manual_seed(seed)
     set_seed(42)
 
-    # Initialize a global random number generator
-    global_rng = random.Random()
 
 
 2.2 Load the fine-tuned BERT model
@@ -526,20 +524,9 @@ We can serialize and save the quantized model for the future use using
 
 .. code:: python
 
-    def ids_tensor(shape, vocab_size, rng=None, name=None):
+    def ids_tensor(shape, vocab_size):
         #  Creates a random int32 tensor of the shape within the vocab size
-        if rng is None:
-            rng = global_rng
-
-        total_dims = 1
-        for dim in shape:
-            total_dims *= dim
-
-        values = []
-        for _ in range(total_dims):
-            values.append(rng.randint(0, vocab_size - 1))
-
-        return torch.tensor(data=values, dtype=torch.long, device='cpu').view(shape).contiguous()
+        return torch.randint(0, vocab_size, shape=shape, dtype=torch.int, device='cpu')
 
     input_ids = ids_tensor([8, 128], 2)
     token_type_ids = ids_tensor([8, 128], 2)

intermediate_source/mario_rl_tutorial.py

@@ -53,6 +53,8 @@
 # Super Mario environment for OpenAI Gym
 import gym_super_mario_bros
 
+from tensordict import TensorDict
+from torchrl.data import TensorDictReplayBuffer, LazyMemmapStorage
 
 ######################################################################
 # RL Definitions
@@ -348,7 +350,7 @@ def act(self, state):
 class Mario(Mario):  # subclassing for continuity
     def __init__(self, state_dim, action_dim, save_dir):
         super().__init__(state_dim, action_dim, save_dir)
-        self.memory = deque(maxlen=100000)
+        self.memory = TensorDictReplayBuffer(storage=LazyMemmapStorage(100000))
         self.batch_size = 32
 
     def cache(self, state, next_state, action, reward, done):
@@ -373,14 +375,15 @@ def first_if_tuple(x):
         reward = torch.tensor([reward], device=self.device)
         done = torch.tensor([done], device=self.device)
 
-        self.memory.append((state, next_state, action, reward, done,))
+        # self.memory.append((state, next_state, action, reward, done,))
+        self.memory.add(TensorDict({"state": state, "next_state": next_state, "action": action, "reward": reward, "done": done}, batch_size=[]))
 
     def recall(self):
         """
         Retrieve a batch of experiences from memory
         """
-        batch = random.sample(self.memory, self.batch_size)
-        state, next_state, action, reward, done = map(torch.stack, zip(*batch))
+        batch = self.memory.sample(self.batch_size)
+        state, next_state, action, reward, done = (batch.get(key) for key in ("state", "next_state", "action", "reward", "done"))
         return state, next_state, action.squeeze(), reward.squeeze(), done.squeeze()
 
 

intermediate_source/torch_compile_tutorial.py

@@ -69,7 +69,7 @@
 
 def foo(x, y):
     a = torch.sin(x)
-    b = torch.cos(x)
+    b = torch.cos(y)
     return a + b
 opt_foo1 = torch.compile(foo)
 print(opt_foo1(torch.randn(10, 10), torch.randn(10, 10)))
@@ -80,7 +80,7 @@ def foo(x, y):
 @torch.compile
 def opt_foo2(x, y):
     a = torch.sin(x)
-    b = torch.cos(x)
+    b = torch.cos(y)
     return a + b
 print(opt_foo2(torch.randn(10, 10), torch.randn(10, 10)))
 

prototype_source/graph_mode_dynamic_bert_tutorial.rst

@@ -60,22 +60,9 @@ Once all the necesessary packages are downloaded and installed we setup the code
     from torch.quantization import per_channel_dynamic_qconfig
     from torch.quantization import quantize_dynamic_jit
 
-    global_rng = random.Random()
-
-    def ids_tensor(shape, vocab_size, rng=None, name=None):
+    def ids_tensor(shape, vocab_size):
         #  Creates a random int32 tensor of the shape within the vocab size
-        if rng is None:
-            rng = global_rng
-
-        total_dims = 1
-        for dim in shape:
-            total_dims *= dim
-
-        values = []
-        for _ in range(total_dims):
-            values.append(rng.randint(0, vocab_size - 1))
-
-        return torch.tensor(data=values, dtype=torch.long, device='cpu').view(shape).contiguous()
+        return torch.randint(0, vocab_size, shape=shape, dtype=torch.int, device='cpu')
 
     # Setup logging
     logger = logging.getLogger(__name__)