Merge branch 'master' into fix-cards-60min-blitz

Author: Svetlana Karslioglu

.jenkins/validate_tutorials_built.py

@@ -22,9 +22,7 @@
     "former_torchies/tensor_tutorial_old",
     "examples_autograd/polynomial_autograd",
     "examples_autograd/polynomial_custom_function",
-    "forward_ad_usage",
     "parametrizations",
-    "reinforcement_q_learning",
     "mnist_train_nas",  # used by ax_multiobjective_nas_tutorial.py
     "fx_conv_bn_fuser",
     "super_resolution_with_onnxruntime",

beginner_source/basics/autogradqs_tutorial.py

@@ -203,14 +203,14 @@
 # compute the product:
 #
 
-inp = torch.eye(5, requires_grad=True)
-out = (inp+1).pow(2)
-out.backward(torch.ones_like(inp), retain_graph=True)
+inp = torch.eye(4, 5, requires_grad=True)
+out = (inp+1).pow(2).t()
+out.backward(torch.ones_like(out), retain_graph=True)
 print(f"First call\n{inp.grad}")
-out.backward(torch.ones_like(inp), retain_graph=True)
+out.backward(torch.ones_like(out), retain_graph=True)
 print(f"\nSecond call\n{inp.grad}")
 inp.grad.zero_()
-out.backward(torch.ones_like(inp), retain_graph=True)
+out.backward(torch.ones_like(out), retain_graph=True)
 print(f"\nCall after zeroing gradients\n{inp.grad}")
 
 

beginner_source/basics/buildmodel_tutorial.py

@@ -77,7 +77,7 @@ def forward(self, x):
 # along with some `background operations <https://github.com/pytorch/pytorch/blob/270111b7b611d174967ed204776985cefca9c144/torch/nn/modules/module.py#L866>`_.
 # Do not call ``model.forward()`` directly!
 #
-# Calling the model on the input returns a 10-dimensional tensor with raw predicted values for each class.
+# Calling the model on the input returns a 2-dimensional tensor with dim=0 corresponding to each output of 10 raw predicted values for each class, and dim=1 corresponding to the individual values of each output.  .
 # We get the prediction probabilities by passing it through an instance of the ``nn.Softmax`` module.
 
 X = torch.rand(1, 28, 28, device=device)

beginner_source/basics/quickstart_tutorial.py

@@ -93,7 +93,7 @@
 # Define model
 class NeuralNetwork(nn.Module):
     def __init__(self):
-        super(NeuralNetwork, self).__init__()
+        super().__init__()
         self.flatten = nn.Flatten()
         self.linear_relu_stack = nn.Sequential(
             nn.Linear(28*28, 512),

beginner_source/fgsm_tutorial.py

@@ -17,7 +17,7 @@
 machine learning. You may be surprised to find that adding imperceptible
 perturbations to an image *can* cause drastically different model
 performance. Given that this is a tutorial, we will explore the topic
-via example on an image classifier. Specifically we will use one of the
+via example on an image classifier. Specifically, we will use one of the
 first and most popular attack methods, the Fast Gradient Sign Attack
 (FGSM), to fool an MNIST classifier.
 

beginner_source/transformer_tutorial.py

@@ -134,6 +134,11 @@ def forward(self, x: Tensor) -> Tensor:
 ######################################################################
 # This tutorial uses ``torchtext`` to generate Wikitext-2 dataset.
 # To access torchtext datasets, please install torchdata following instructions at https://github.com/pytorch/data. 
+# %%
+#  .. code-block:: bash
+#
+#      %%bash
+#      pip install torchdata
 #
 # The vocab object is built based on the train dataset and is used to numericalize
 # tokens into tensors. Wikitext-2 represents rare tokens as `<unk>`.

beginner_source/translation_transformer.py

@@ -309,7 +309,7 @@ def train_epoch(model, optimizer):
         optimizer.step()
         losses += loss.item()
 
-    return losses / len(train_dataloader)
+    return losses / len(list(train_dataloader))
 
 
 def evaluate(model):
@@ -333,7 +333,7 @@ def evaluate(model):
         loss = loss_fn(logits.reshape(-1, logits.shape[-1]), tgt_out.reshape(-1))
         losses += loss.item()
 
-    return losses / len(val_dataloader)
+    return losses / len(list(val_dataloader))
 
 ######################################################################
 # Now we have all the ingredients to train our model. Let's do it!

intermediate_source/mario_rl_tutorial.py

@@ -31,8 +31,10 @@
 ######################################################################
 #
 #
-
-# !pip install gym-super-mario-bros==7.3.0
+#  .. code-block:: bash
+#
+#      %%bash
+#      pip install gym-super-mario-bros==7.4.0
 
 import torch
 from torch import nn
@@ -95,16 +97,19 @@
 # (next) state, reward and other info.
 #
 
-# Initialize Super Mario environment
-env = gym_super_mario_bros.make("SuperMarioBros-1-1-v0")
+# Initialize Super Mario environment (in v0.26 change render mode to 'human' to see results on the screen)
+if gym.__version__ < '0.26':
+    env = gym_super_mario_bros.make("SuperMarioBros-1-1-v0", new_step_api=True)
+else:
+    env = gym_super_mario_bros.make("SuperMarioBros-1-1-v0", render_mode='rgb', apply_api_compatibility=True)
 
 # Limit the action-space to
 #   0. walk right
 #   1. jump right
 env = JoypadSpace(env, [["right"], ["right", "A"]])
 
 env.reset()
-next_state, reward, done, info = env.step(action=0)
+next_state, reward, done, trunc, info = env.step(action=0)
 print(f"{next_state.shape},\n {reward},\n {done},\n {info}")
 
 
@@ -151,14 +156,13 @@ def __init__(self, env, skip):
     def step(self, action):
         """Repeat action, and sum reward"""
         total_reward = 0.0
-        done = False
         for i in range(self._skip):
             # Accumulate reward and repeat the same action
-            obs, reward, done, info = self.env.step(action)
+            obs, reward, done, trunk, info = self.env.step(action)
             total_reward += reward
             if done:
                 break
-        return obs, total_reward, done, info
+        return obs, total_reward, done, trunk, info
 
 
 class GrayScaleObservation(gym.ObservationWrapper):
@@ -203,7 +207,10 @@ def observation(self, observation):
 env = SkipFrame(env, skip=4)
 env = GrayScaleObservation(env)
 env = ResizeObservation(env, shape=84)
-env = FrameStack(env, num_stack=4)
+if gym.__version__ < '0.26':
+    env = FrameStack(env, num_stack=4, new_step_api=True)
+else:
+    env = FrameStack(env, num_stack=4)
 
 
 ######################################################################
@@ -283,12 +290,11 @@ def __init__(self, state_dim, action_dim, save_dir):
         self.action_dim = action_dim
         self.save_dir = save_dir
 
-        self.use_cuda = torch.cuda.is_available()
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
 
         # Mario's DNN to predict the most optimal action - we implement this in the Learn section
         self.net = MarioNet(self.state_dim, self.action_dim).float()
-        if self.use_cuda:
-            self.net = self.net.to(device="cuda")
+        self.net = self.net.to(device=self.device)
 
         self.exploration_rate = 1
         self.exploration_rate_decay = 0.99999975
@@ -312,12 +318,8 @@ def act(self, state):
 
         # EXPLOIT
         else:
-            state = state.__array__()
-            if self.use_cuda:
-                state = torch.tensor(state).cuda()
-            else:
-                state = torch.tensor(state)
-            state = state.unsqueeze(0)
+            state = state[0].__array__() if isinstance(state, tuple) else state.__array__()
+            state = torch.tensor(state, device=self.device).unsqueeze(0)
             action_values = self.net(state, model="online")
             action_idx = torch.argmax(action_values, axis=1).item()
 
@@ -363,21 +365,16 @@ def cache(self, state, next_state, action, reward, done):
         reward (float),
         done(bool))
         """
-        state = state.__array__()
-        next_state = next_state.__array__()
-
-        if self.use_cuda:
-            state = torch.tensor(state).cuda()
-            next_state = torch.tensor(next_state).cuda()
-            action = torch.tensor([action]).cuda()
-            reward = torch.tensor([reward]).cuda()
-            done = torch.tensor([done]).cuda()
-        else:
-            state = torch.tensor(state)
-            next_state = torch.tensor(next_state)
-            action = torch.tensor([action])
-            reward = torch.tensor([reward])
-            done = torch.tensor([done])
+        def first_if_tuple(x):
+            return x[0] if isinstance(x, tuple) else x
+        state = first_if_tuple(state).__array__()
+        next_state = first_if_tuple(next_state).__array__()
+
+        state = torch.tensor(state, device=self.device)
+        next_state = torch.tensor(next_state, device=self.device)
+        action = torch.tensor([action], device=self.device)
+        reward = torch.tensor([reward], device=self.device)
+        done = torch.tensor([done], device=self.device)
 
         self.memory.append((state, next_state, action, reward, done,))
 
@@ -753,7 +750,7 @@ def record(self, episode, epsilon, step):
         action = mario.act(state)
 
         # Agent performs action
-        next_state, reward, done, info = env.step(action)
+        next_state, reward, done, trunc, info = env.step(action)
 
         # Remember
         mario.cache(state, next_state, action, reward, done)

intermediate_source/reinforcement_q_learning.py

@@ -46,7 +46,12 @@
 
 First, let's import needed packages. Firstly, we need
 `gym <https://github.com/openai/gym>`__ for the environment
-(Install using `pip install gym`).
+
+.. code-block:: bash
+
+   %%bash
+   pip3 install gym[classic_control]
+
 We'll also use the following from PyTorch:
 
 -  neural networks (``torch.nn``)
@@ -74,7 +79,10 @@
 import torchvision.transforms as T
 
 
-env = gym.make('CartPole-v0', new_step_api=True, render_mode='single_rgb_array').unwrapped
+if gym.__version__ < '0.26':
+    env = gym.make('CartPole-v0', new_step_api=True, render_mode='single_rgb_array').unwrapped
+else:
+    env = gym.make('CartPole-v0', render_mode='rgb_array').unwrapped
 
 # set up matplotlib
 is_ipython = 'inline' in matplotlib.get_backend()

intermediate_source/text_to_speech_with_torchaudio.py

@@ -293,12 +293,28 @@ def text_to_sequence(text):
 # Waveglow
 # ~~~~~~~~
 # 
-# Waveglow is a vocoder published by Nvidia. The pretrained weight is
-# publishe on Torch Hub. One can instantiate the model using ``torch.hub``
+# Waveglow is a vocoder published by Nvidia. The pretrained weights are
+# published on Torch Hub. One can instantiate the model using ``torch.hub``
 # module.
 # 
+if torch.cuda.is_available():
+  waveglow = torch.hub.load('NVIDIA/DeepLearningExamples:torchhub', 'nvidia_waveglow', model_math='fp32')
+else:
+  # Workaround to load model mapped on GPU
+  # https://stackoverflow.com/a/61840832
+  waveglow = torch.hub.load(
+      "NVIDIA/DeepLearningExamples:torchhub",
+      "nvidia_waveglow",
+      model_math="fp32",
+      pretrained=False,
+  )
+  checkpoint = torch.hub.load_state_dict_from_url(
+      "https://api.ngc.nvidia.com/v2/models/nvidia/waveglow_ckpt_fp32/versions/19.09.0/files/nvidia_waveglowpyt_fp32_20190427",
+      progress=False,
+      map_location=device,
+  )
+  state_dict = {key.replace("module.", ""): value for key, value in checkpoint["state_dict"].items()}
 
-waveglow = torch.hub.load('NVIDIA/DeepLearningExamples:torchhub', 'nvidia_waveglow', model_math='fp32')
 waveglow = waveglow.remove_weightnorm(waveglow)
 waveglow = waveglow.to(device)
 waveglow.eval()

recipes_source/intel_extension_for_pytorch.rst

@@ -98,7 +98,7 @@ Float32
    model.set_state_dict(torch.load(PATH))
    optimizer.set_state_dict(torch.load(PATH))
    # Invoke optimize function against the model object and optimizer object
-   model, optimizer = ipex.optimize(model, optimizer, dtype=torch.float32)
+   model, optimizer = ipex.optimize(model, optimizer=optimizer)
    
    for images, label in train_loader():
        # Setting memory_format to torch.channels_last could improve performance with 4D input data. This is optional.
@@ -131,7 +131,7 @@ BFloat16
    model.set_state_dict(torch.load(PATH))
    optimizer.set_state_dict(torch.load(PATH))
    # Invoke optimize function against the model object and optimizer object with data type set to torch.bfloat16
-   model, optimizer = ipex.optimize(model, optimizer, dtype=torch.bfloat16)
+   model, optimizer = ipex.optimize(model, optimizer=optimizer, dtype=torch.bfloat16)
    
    for images, label in train_loader():
        with torch.cpu.amp.autocast():

requirements.txt

@@ -43,6 +43,7 @@ scikit-image
 scipy
 pillow==9.0.1
 wget
-gym==0.24.0
-gym-super-mario-bros==7.3.0
+gym==0.25.1
+gym-super-mario-bros==7.4.0
 timm
+pygame==2.1.2