Homogenize dataloader names

Author: bpesquet

pytorch_tutorial/logistic_regression/README.md

@@ -92,12 +92,12 @@ The PyTorch [DataLoader](https://pytorch.org/docs/stable/data.html#torch.utils.d
 
 ```python
 # Create data loader for loading data as randomized batches
-blobs_dataloader = DataLoader(
+train_dataloader = DataLoader(
     list(zip(x_train, y_train)), batch_size=batch_size, shuffle=True
 )
 
 # Number of batches in an epoch (= n_samples / batch_size, rounded up)
-n_batches = len(blobs_dataloader)
+n_batches = len(train_dataloader)
 assert n_batches == math.ceil(n_samples / batch_size)
 ```
 
@@ -132,13 +132,13 @@ assert n_params == 3 * output_dim
 
 ## Loss function
 
-This classification example uses the [cross-entropy](https://github.com/bpesquet/mlcourse/tree/main/lectures/classification_performance#assessing-performance-during-training-1) a.k.a. negative log-likelihood loss function, implemented by the [CrossEntropyLoss](https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html) class.
+This multiclass classification example uses the [cross-entropy](https://github.com/bpesquet/mlcourse/tree/main/lectures/classification_performance#assessing-performance-during-training-1) a.k.a. negative log-likelihood loss function, implemented by the [CrossEntropyLoss](https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html) class.
 
 > [!NOTE]
 > PyTorch also offers the [NLLLoss](https://pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html#torch.nn.NLLLoss) class implementing the negative log-likelihood loss. A key difference is that `CrossEntropyLoss` expects *logits*  (raw, unnormalized predictions) as inputs, and uses [LogSoftmax](https://pytorch.org/docs/stable/generated/torch.nn.LogSoftmax.html#torch.nn.LogSoftmax) to transform them into probabilities before computing its output. Using `CrossEntropyLoss` is equivalent to applying `LogSoftmax` followed by `NLLLoss` ([more details](https://towardsdatascience.com/cross-entropy-negative-log-likelihood-and-all-that-jazz-47a95bd2e81)).
 
 ```python
-# Use cross-entropy loss function.
+# Use cross-entropy loss function for this multiclass classification task.
 # Softmax is computed internally to convert outputs into probabilities
 criterion = nn.CrossEntropyLoss()
 ```
@@ -176,7 +176,7 @@ for epoch in range(n_epochs):
     n_correct = 0
 
     # For each batch of data
-    for x_batch, y_batch in blobs_dataloader:
+    for x_batch, y_batch in train_dataloader:
         # Forward pass
         y_pred = model(x_batch)
 
@@ -310,7 +310,6 @@ def plot_decision_boundaries(model, x, y, title, device):
     plt.legend(handles=legend_elements)
 
     plt.title(title)
-    plt.tight_layout()
 
     return plt.gcf()
 ```

pytorch_tutorial/logistic_regression/test_logistic_regression.py

@@ -51,12 +51,12 @@ def test_logistic_regression(show_plots=False):
     y_train = torch.from_numpy(targets).long().to(device)
 
     # Create data loader for loading data as randomized batches
-    blobs_dataloader = DataLoader(
+    train_dataloader = DataLoader(
         list(zip(x_train, y_train)), batch_size=batch_size, shuffle=True
     )
 
     # Number of batches in an epoch (= n_samples / batch_size, rounded up)
-    n_batches = len(blobs_dataloader)
+    n_batches = len(train_dataloader)
     assert n_batches == math.ceil(n_samples / batch_size)
 
     # Create a logistic regression model for the 2D dataset
@@ -71,7 +71,7 @@ def test_logistic_regression(show_plots=False):
     # Linear layers have (in_features + 1) * out_features parameters
     assert n_params == 3 * output_dim
 
-    # Use cross-entropy loss function.
+    # Use cross-entropy loss function for this multiclass classification task.
     # Softmax is computed internally to convert outputs into probabilities
     criterion = nn.CrossEntropyLoss()
 
@@ -91,7 +91,7 @@ def test_logistic_regression(show_plots=False):
         n_correct = 0
 
         # For each batch of data
-        for x_batch, y_batch in blobs_dataloader:
+        for x_batch, y_batch in train_dataloader:
             # Forward pass
             y_pred = model(x_batch)
 

pytorch_tutorial/multilayer_perceptron/README.md

@@ -95,12 +95,12 @@ The PyTorch [DataLoader](https://pytorch.org/docs/stable/data.html#torch.utils.d
 
 ```python
 # Create data loader for loading data as randomized batches
-circles_dataloader = DataLoader(
+train_dataloader = DataLoader(
     list(zip(x_train, y_train)), batch_size=batch_size, shuffle=True
 )
 
 # Number of batches in an epoch (= n_samples / batch_size, rounded up)
-n_batches = len(circles_dataloader)
+n_batches = len(train_dataloader)
 assert n_batches == math.ceil(n_samples / batch_size)
 ```
 
@@ -151,7 +151,7 @@ assert n_params == 3 * hidden_layer_dim + hidden_layer_dim + 1
 For this binary classification task, we use the [binary cross-entropy](https://github.com/bpesquet/mlcourse/tree/main/lectures/classification_performance#choosing-a-loss-function) loss function, implemented bye the PyTorch [BCELoss](https://pytorch.org/docs/stable/generated/torch.nn.BCELoss.html) class.
 
 ```python
-# Use binary cross-entropy loss function
+# Use binary cross-entropy loss function for this binary classification task
 criterion = nn.BCELoss()
 ```
 
@@ -186,7 +186,7 @@ for epoch in range(n_epochs):
     n_correct = 0
 
     # For each batch of data
-    for x_batch, y_batch in circles_dataloader:
+    for x_batch, y_batch in train_dataloader:
         # Forward pass
         y_pred = model(x_batch)
 

pytorch_tutorial/multilayer_perceptron/test_multilayer_perceptron.py

@@ -1,5 +1,5 @@
 """
-MultiLayer Perceptron (MLP) a.k.a. Feedforward Neural Network 
+MultiLayer Perceptron (MLP) a.k.a. Feedforward Neural Network
 """
 
 import math
@@ -52,12 +52,12 @@ def test_multilayer_perceptron(show_plots=False):
     assert y_train.shape == torch.Size([n_samples, 1])
 
     # Create data loader for loading data as randomized batches
-    circles_dataloader = DataLoader(
+    train_dataloader = DataLoader(
         list(zip(x_train, y_train)), batch_size=batch_size, shuffle=True
     )
 
     # Number of batches in an epoch (= n_samples / batch_size, rounded up)
-    n_batches = len(circles_dataloader)
+    n_batches = len(train_dataloader)
     assert n_batches == math.ceil(n_samples / batch_size)
 
     # Create a MultiLayer Perceptron with 2 inputs, a hidden layer and 1 output
@@ -83,7 +83,7 @@ def test_multilayer_perceptron(show_plots=False):
     # Output layer has (hidden_layer_dim + 1) * 1 parameters
     assert n_params == 3 * hidden_layer_dim + hidden_layer_dim + 1
 
-    # Use binary cross-entropy loss function
+    # Use binary cross-entropy loss function for this binary classification task
     criterion = nn.BCELoss()
 
     # Use a vanilla mini-batch stochastic gradient descent optimizer
@@ -102,7 +102,7 @@ def test_multilayer_perceptron(show_plots=False):
         n_correct = 0
 
         # For each batch of data
-        for x_batch, y_batch in circles_dataloader:
+        for x_batch, y_batch in train_dataloader:
             # Forward pass
             y_pred = model(x_batch)