diff --git a/beginner_source/introyt/tensorboardyt_tutorial.py b/beginner_source/introyt/tensorboardyt_tutorial.py
index 49d321bd6df..ff6a3031d27 100644
--- a/beginner_source/introyt/tensorboardyt_tutorial.py
+++ b/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)
diff --git a/beginner_source/introyt/trainingyt.py b/beginner_source/introyt/trainingyt.py
index d9f585411e8..8b27922127c 100644
--- a/beginner_source/introyt/trainingyt.py
+++ b/beginner_source/introyt/trainingyt.py
@@ -57,7 +57,7 @@
 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.
 
@@ -65,16 +65,18 @@
 
 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,7 +278,7 @@ 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
@@ -284,7 +286,7 @@ def train_one_epoch(epoch_index, tb_writer):
 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