Merge branch 'main' into fix/3855-deprecated-inplace-ops

Author: sekyondaMeta

beginner_source/basics/data_tutorial.py

@@ -48,22 +48,22 @@
 import torch
 from torch.utils.data import Dataset
 from torchvision import datasets
-from torchvision.transforms import ToTensor
+from torchvision.transforms import v2
 import matplotlib.pyplot as plt
 
 
 training_data = datasets.FashionMNIST(
     root="data",
     train=True,
     download=True,
-    transform=ToTensor()
+    transform=v2.Compose([v2.ToImage(), v2.ToDtype(torch.float32, scale=True)])
 )
 
 test_data = datasets.FashionMNIST(
     root="data",
     train=False,
     download=True,
-    transform=ToTensor()
+    transform=v2.Compose([v2.ToImage(), v2.ToDtype(torch.float32, scale=True)])
 )
 
 

beginner_source/basics/optimization_tutorial.py

@@ -28,20 +28,20 @@
 from torch import nn
 from torch.utils.data import DataLoader
 from torchvision import datasets
-from torchvision.transforms import ToTensor
+from torchvision.transforms import v2
 
 training_data = datasets.FashionMNIST(
     root="data",
     train=True,
     download=True,
-    transform=ToTensor()
+    transform=v2.Compose([v2.ToImage(), v2.ToDtype(torch.float32, scale=True)])
 )
 
 test_data = datasets.FashionMNIST(
     root="data",
     train=False,
     download=True,
-    transform=ToTensor()
+    transform=v2.Compose([v2.ToImage(), v2.ToDtype(torch.float32, scale=True)])
 )
 
 train_dataloader = DataLoader(training_data, batch_size=64)

beginner_source/basics/transforms_tutorial.py

@@ -23,42 +23,47 @@
 
 The FashionMNIST features are in PIL Image format, and the labels are integers.
 For training, we need the features as normalized tensors, and the labels as one-hot encoded tensors.
-To make these transformations, we use ``ToTensor`` and ``Lambda``.
+To make these transformations, we use the ``torchvision.transforms.v2`` API along with ``torch.nn.functional.one_hot``.
 """
 
 import torch
+import torch.nn.functional as F
 from torchvision import datasets
-from torchvision.transforms import ToTensor, Lambda
+from torchvision.transforms import v2
 
 ds = datasets.FashionMNIST(
     root="data",
     train=True,
     download=True,
-    transform=ToTensor(),
-    target_transform=Lambda(lambda y: torch.zeros(10, dtype=torch.float).scatter_(0, torch.tensor(y), value=1))
+    transform=v2.Compose([v2.ToImage(), v2.ToDtype(torch.float32, scale=True)]),
+    target_transform=v2.Lambda(
+        lambda y: F.one_hot(torch.tensor(y), num_classes=10).float()
+    ),
 )
 
 #################################################
-# ToTensor()
+# ToImage() and ToDtype()
 # -------------------------------
 #
-# `ToTensor <https://pytorch.org/vision/stable/transforms.html#torchvision.transforms.ToTensor>`_
-# converts a PIL image or NumPy ``ndarray`` into a ``FloatTensor``. and scales
-# the image's pixel intensity values in the range [0., 1.]
+# The ``torchvision.transforms.v2`` API replaces the legacy ``ToTensor`` transform with a two-step pipeline.
+# `v2.ToImage <https://pytorch.org/vision/stable/generated/torchvision.transforms.v2.ToImage.html>`_
+# converts a PIL image or NumPy ``ndarray`` into a ``torchvision.tv_tensors.Image`` tensor, and
+# `v2.ToDtype <https://pytorch.org/vision/stable/generated/torchvision.transforms.v2.ToDtype.html>`_
+# with ``scale=True`` casts it to ``float32`` and scales the pixel intensity values to the range [0., 1.].
 #
 
 ##############################################
 # Lambda Transforms
 # -------------------------------
 #
-# Lambda transforms apply any user-defined lambda function. Here, we define a function
-# to turn the integer into a one-hot encoded tensor.
-# It first creates a zero tensor of size 10 (the number of labels in our dataset) and calls
-# `scatter_ <https://pytorch.org/docs/stable/generated/torch.Tensor.scatter_.html>`_ which assigns a
-# ``value=1`` on the index as given by the label ``y``.
+# Lambda transforms apply any user-defined lambda function. Here, we use
+# `torch.nn.functional.one_hot <https://pytorch.org/docs/stable/generated/torch.nn.functional.one_hot.html>`_
+# to turn the integer label into a one-hot encoded tensor of size 10 (the number of labels in our dataset),
+# then cast it to ``float`` to match the expected dtype.
 
-target_transform = Lambda(lambda y: torch.zeros(
-    10, dtype=torch.float).scatter_(dim=0, index=torch.tensor(y), value=1))
+target_transform = v2.Lambda(
+    lambda y: F.one_hot(torch.tensor(y), num_classes=10).float()
+)
 
 ######################################################################
 # --------------
@@ -67,4 +72,5 @@
 #################################################################
 # Further Reading
 # ~~~~~~~~~~~~~~~~~
-# - `torchvision.transforms API <https://pytorch.org/vision/stable/transforms.html>`_
+# - `Getting started with transforms v2 <https://pytorch.org/vision/stable/auto_examples/transforms/plot_transforms_getting_started.html>`_
+# - `torchvision.transforms.v2 API <https://pytorch.org/vision/stable/transforms.html#v2-api-reference-recommended>`_

beginner_source/introyt/tensorboardyt_tutorial.py

@@ -59,7 +59,7 @@
 
 # Image datasets and image manipulation
 import torchvision
-import torchvision.transforms as transforms
+from torchvision.transforms import v2
 
 # Image display
 import matplotlib.pyplot as plt
@@ -68,14 +68,6 @@
 # PyTorch TensorBoard support
 from torch.utils.tensorboard import SummaryWriter
 
-# In case you are using an environment that has TensorFlow installed,
-# such as Google Colab, uncomment the following code to avoid
-# a bug with saving embeddings to your TensorBoard directory
-
-# import tensorflow as tf
-# import tensorboard as tb
-# tf.io.gfile = tb.compat.tensorflow_stub.io.gfile
-
 ######################################################################
 # Showing Images in TensorBoard
 # -----------------------------
@@ -84,9 +76,10 @@
 # 
 
 # Gather datasets and prepare them for consumption
-transform = transforms.Compose(
-    [transforms.ToTensor(),
-    transforms.Normalize((0.5,), (0.5,))])
+transform = v2.Compose([
+    v2.ToImage(),
+    v2.ToDtype(torch.float32, scale=True),
+    v2.Normalize((0.5,), (0.5,))])
 
 # Store separate training and validations splits in ./data
 training_set = torchvision.datasets.FashionMNIST('./data',
@@ -171,7 +164,7 @@ def matplotlib_imshow(img, one_channel=False):
 
 class Net(nn.Module):
     def __init__(self):
-        super(Net, self).__init__()
+        super().__init__()
         self.conv1 = nn.Conv2d(1, 6, 5)
         self.pool = nn.MaxPool2d(2, 2)
         self.conv2 = nn.Conv2d(6, 16, 5)
@@ -214,18 +207,19 @@ def forward(self, x):
 
         running_loss += loss.item()
         if i % 1000 == 999:    # Every 1000 mini-batches...
-            print('Batch {}'.format(i + 1))
+            print(f'Batch {i + 1}')
             # Check against the validation set
             running_vloss = 0.0
 
             # In evaluation mode some model specific operations can be omitted eg. dropout layer
-            net.train(False) # Switching to evaluation mode, eg. turning off regularisation
-            for j, vdata in enumerate(validation_loader, 0):
-                vinputs, vlabels = vdata
-                voutputs = net(vinputs)
-                vloss = criterion(voutputs, vlabels)
-                running_vloss += vloss.item()
-            net.train(True) # Switching back to training mode, eg. turning on regularisation
+            net.eval() # Switching to evaluation mode, eg. turning off regularisation
+            with torch.no_grad():
+                for j, vdata in enumerate(validation_loader, 0):
+                    vinputs, vlabels = vdata
+                    voutputs = net(vinputs)
+                    vloss = criterion(voutputs, vlabels)
+                    running_vloss += vloss.item()
+            net.train() # Switching back to training mode, eg. turning on regularisation
 
             avg_loss = running_loss / 1000
             avg_vloss = running_vloss / len(validation_loader)

beginner_source/introyt/trainingyt.py

@@ -57,24 +57,26 @@
 of data they contain.
  
 For this tutorial, we’ll be using the Fashion-MNIST dataset provided by
-TorchVision. We use ``torchvision.transforms.Normalize()`` to
+TorchVision. We use ``torchvision.transforms.v2.Normalize()`` to
 zero-center and normalize the distribution of the image tile content,
 and download both training and validation data splits.
 
 """ 
 
 import torch
 import torchvision
-import torchvision.transforms as transforms
+from torchvision.transforms import v2
 
 # PyTorch TensorBoard support
 from torch.utils.tensorboard import SummaryWriter
 from datetime import datetime
 
 
-transform = transforms.Compose(
-    [transforms.ToTensor(),
-    transforms.Normalize((0.5,), (0.5,))])
+transform = v2.Compose([
+    v2.ToImage(),
+    v2.ToDtype(torch.float32, scale=True),
+    v2.Normalize((0.5,), (0.5,))
+])
 
 # Create datasets for training & validation, download if necessary
 training_set = torchvision.datasets.FashionMNIST('./data', train=True, transform=transform, download=True)
@@ -89,8 +91,8 @@
         'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle Boot')
 
 # Report split sizes
-print('Training set has {} instances'.format(len(training_set)))
-print('Validation set has {} instances'.format(len(validation_set)))
+print(f'Training set has {len(training_set)} instances')
+print(f'Validation set has {len(validation_set)} instances')
 
 
 ######################################################################
@@ -134,7 +136,7 @@ def matplotlib_imshow(img, one_channel=False):
 # PyTorch models inherit from torch.nn.Module
 class GarmentClassifier(nn.Module):
     def __init__(self):
-        super(GarmentClassifier, self).__init__()
+        super().__init__()
         self.conv1 = nn.Conv2d(1, 6, 5)
         self.pool = nn.MaxPool2d(2, 2)
         self.conv2 = nn.Conv2d(6, 16, 5)
@@ -176,7 +178,7 @@ def forward(self, x):
 print(dummy_labels)
 
 loss = loss_fn(dummy_outputs, dummy_labels)
-print('Total loss for this batch: {}'.format(loss.item()))
+print(f'Total loss for this batch: {loss.item()}')
 
 
 #################################################################################
@@ -251,7 +253,7 @@ def train_one_epoch(epoch_index, tb_writer):
         running_loss += loss.item()
         if i % 1000 == 999:
             last_loss = running_loss / 1000 # loss per batch
-            print('  batch {} loss: {}'.format(i + 1, last_loss))
+            print(f'  batch {i + 1} loss: {last_loss}')
             tb_x = epoch_index * len(training_loader) + i + 1
             tb_writer.add_scalar('Loss/train', last_loss, tb_x)
             running_loss = 0.
@@ -276,15 +278,15 @@ def train_one_epoch(epoch_index, tb_writer):
 
 # Initializing in a separate cell so we can easily add more epochs to the same run
 timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-writer = SummaryWriter('runs/fashion_trainer_{}'.format(timestamp))
+writer = SummaryWriter(f'runs/fashion_trainer_{timestamp}')
 epoch_number = 0
 
 EPOCHS = 5
 
 best_vloss = 1_000_000.
 
 for epoch in range(EPOCHS):
-    print('EPOCH {}:'.format(epoch_number + 1))
+    print(f'EPOCH {epoch_number + 1}:')
 
     # Make sure gradient tracking is on, and do a pass over the data
     model.train(True)
@@ -305,7 +307,7 @@ def train_one_epoch(epoch_index, tb_writer):
             running_vloss += vloss
 
     avg_vloss = running_vloss / (i + 1)
-    print('LOSS train {} valid {}'.format(avg_loss, avg_vloss))
+    print(f'LOSS train {avg_loss} valid {avg_vloss}')
 
     # Log the running loss averaged per batch
     # for both training and validation
@@ -317,7 +319,7 @@ def train_one_epoch(epoch_index, tb_writer):
     # Track best performance, and save the model's state
     if avg_vloss < best_vloss:
         best_vloss = avg_vloss
-        model_path = 'model_{}_{}'.format(timestamp, epoch_number)
+        model_path = f'model_{timestamp}_{epoch_number}'
         torch.save(model.state_dict(), model_path)
 
     epoch_number += 1