Fix code indents

Author: mikebo93

chapter_programming_model/Bridging_Python_and_C_C++_Functions.md

@@ -66,33 +66,33 @@ In C++:
 **ch02/code2.5.1**
 ```cpp
 //custom_add.cpp
-    #include <torch/extension.h>
-    #include <pybind11/pybind11.h>
-    
-    torch::Tensor custom_add(torch::Tensor a, torch::Tensor b) {
-        return a + b;
-    }
-    
-    PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
-        m.def("custom_add", &custom_add, "A custom add function");
-    }
+#include <torch/extension.h>
+#include <pybind11/pybind11.h>
+
+torch::Tensor custom_add(torch::Tensor a, torch::Tensor b) {
+    return a + b;
+}
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
+    m.def("custom_add", &custom_add, "A custom add function");
+}
 ```
 
 In Python:
 
 **ch02/code2.5.2**
 ```python
 import torch
-    from torch.utils.cpp_extension import load
-    
-    # Load the C++ extension
-    custom_extension = load(
-        name='custom_extension',
-        sources=['custom_add.cpp'],
-        verbose=True
-    )
-    # Use your custom add function
-    a = torch.randn(10)
-    b = torch.randn(10)
-    c = custom_extension.custom_add(a, b)
+from torch.utils.cpp_extension import load
+
+# Load the C++ extension
+custom_extension = load(
+    name='custom_extension',
+    sources=['custom_add.cpp'],
+    verbose=True
+)
+# Use your custom add function
+a = torch.randn(10)
+b = torch.randn(10)
+c = custom_extension.custom_add(a, b)
 ```

chapter_programming_model/Functional_Programming.md

@@ -85,10 +85,10 @@ for distributed parallelism in PyTorch static graphs. Code
 **ch02/code2.4**
 ```
 from functorch import combine_state_for_ensemble, vmap
-    minibatches = data[:num_models]
-    models = [MLP().to(device) for _ in range(num_models)]
-    fmodel, params, buffers = combine_state_for_ensemble(models)
-    predictions1_vmap = vmap(fmodel, out_dims=1)(params, buffers, minibatches)
+minibatches = data[:num_models]
+models = [MLP().to(device) for _ in range(num_models)]
+fmodel, params, buffers = combine_state_for_ensemble(models)
+predictions1_vmap = vmap(fmodel, out_dims=1)(params, buffers, minibatches)
 ```
 
 Functorch introduces *vmap*, standing for \"vectorized map\". Its role

chapter_programming_model/Machine_Learning_Workflow.md

@@ -18,29 +18,29 @@ APIs are defined to facilitate customization within the workflow
 **ch02/code2.2.1**
 ```python
 import pickle
-    from torch.utils.data import Dataset, DataLoader
-    data_path = '/path/to/data'
-    dataset = pickle.load(open(data_path, 'rb')) # Example for a pkl file
-    batch_size = ... # You can make it an argument of the script
-    
-    class CustomDataset(Dataset):
-        def __init__(self, data, labels):
-            self.data = data
-            self.labels = labels
-            
-        def __len__(self):
-            return len(self.data)
-            
-        def __getitem__(self, idx):
-            sample = self.data[idx]
-            label = self.labels[idx]
-            return sample, label
-    
-    training_dataset = CustomDataset(dataset['training_data'], dataset['training_labels'])
-    testing_dataset = CustomDataset(dataset['testing_data'], dataset['testing_labels'])
-
-    training_dataloader = DataLoader(training_dataset, batch_size=batch_size, shuffle=True)  # Create a training dataloader
-    testing_dataloader = DataLoader(testing_dataset, batch_size=batch_size, shuffle=False) # Create a testing dataloader
+from torch.utils.data import Dataset, DataLoader
+data_path = '/path/to/data'
+dataset = pickle.load(open(data_path, 'rb')) # Example for a pkl file
+batch_size = ... # You can make it an argument of the script
+
+class CustomDataset(Dataset):
+    def __init__(self, data, labels):
+        self.data = data
+        self.labels = labels
+        
+    def __len__(self):
+        return len(self.data)
+        
+    def __getitem__(self, idx):
+        sample = self.data[idx]
+        label = self.labels[idx]
+        return sample, label
+
+training_dataset = CustomDataset(dataset['training_data'], dataset['training_labels'])
+testing_dataset = CustomDataset(dataset['testing_data'], dataset['testing_labels'])
+
+training_dataloader = DataLoader(training_dataset, batch_size=batch_size, shuffle=True)  # Create a training dataloader
+testing_dataloader = DataLoader(testing_dataset, batch_size=batch_size, shuffle=False) # Create a testing dataloader
 ```
 
 2.  **Model Definition API:** Once the data is preprocessed, users need
@@ -53,13 +53,13 @@ import pickle
 **ch02/code2.2.2**
 ```python
 import torch.nn as nn
-    class CustomModel(nn.Module):
-        def __init__(self, input_size, output_size):
-            super(CustomModel, self).__init__()
-            self.linear = nn.Linear(input_size, output_size)  # A single linear layer
-    
-        def forward(self, x):
-            return self.linear(x)
+class CustomModel(nn.Module):
+    def __init__(self, input_size, output_size):
+        super(CustomModel, self).__init__()
+        self.linear = nn.Linear(input_size, output_size)  # A single linear layer
+
+    def forward(self, x):
+        return self.linear(x)
 ```
 
 3.  **Optimizer Definition API:** The outputs of models need to be
@@ -74,11 +74,11 @@ import torch.nn as nn
 **ch02/code2.2.3**
 ```python
 import torch.optim as optim
-    import torch.nn
-    model = CustomModel(...)
-    # Optimizer definition (Adam, SGD, etc.)
-    optimizer = optim.Adam(model.parameters(), lr=1e-4, momentum=0.9) 
-    loss = nn.CrossEntropyLoss() # Loss function definition
+import torch.nn
+model = CustomModel(...)
+# Optimizer definition (Adam, SGD, etc.)
+optimizer = optim.Adam(model.parameters(), lr=1e-4, momentum=0.9) 
+loss = nn.CrossEntropyLoss() # Loss function definition
 ```
 
 4.  **Training API:** Given a dataset, model, loss function, and
@@ -92,17 +92,17 @@ import torch.optim as optim
 **ch02/code2.2.4**
 ```python
 device = "cuda:0" if torch.cuda.is_available() else "cpu" # Select your training device
-    model.to(device) # Move the model to the training device
-    model.train() # Set the model to train mode
-    epochs = ... # You can make it an argument of the script
-    for epoch in range(epochs):
-        for batch_idx, (data, target) in enumerate(training_dataloader):
-            data, target = data.to(device), target.to(device)
-            optimizer.zero_grad() # zero the parameter gradients
-            output = model(data) # Forward pass
-            loss_value = loss(output, target) # Compute the loss
-            loss_value.backward() # Backpropagation
-            optimizer.step()
+model.to(device) # Move the model to the training device
+model.train() # Set the model to train mode
+epochs = ... # You can make it an argument of the script
+for epoch in range(epochs):
+    for batch_idx, (data, target) in enumerate(training_dataloader):
+        data, target = data.to(device), target.to(device)
+        optimizer.zero_grad() # zero the parameter gradients
+        output = model(data) # Forward pass
+        loss_value = loss(output, target) # Compute the loss
+        loss_value.backward() # Backpropagation
+        optimizer.step()
 ```
 
 5.  **Testing and Debugging APIs:** Throughout the training process,
@@ -116,13 +116,13 @@ device = "cuda:0" if torch.cuda.is_available() else "cpu" # Select your training
 **ch02/code2.2.5**
 ```python
 model.eval() # Set the model to evaluation mode
-    overall_accuracy = []
-    for batch_idx, (data, target) in enumerate(testing_dataloader):
-        data, target = data.to(device), target.to(device)
-        output = model(data) # Forward pass
-        accuracy = your_metrics(output, target) # Compute the accuracy
-        overall_accuracy.append(accuracy) # Print the accuracy
-    # For debugging, you can print logs inside the training or evaluation loop, or use python debugger.
+overall_accuracy = []
+for batch_idx, (data, target) in enumerate(testing_dataloader):
+    data, target = data.to(device), target.to(device)
+    output = model(data) # Forward pass
+    accuracy = your_metrics(output, target) # Compute the accuracy
+    overall_accuracy.append(accuracy) # Print the accuracy
+# For debugging, you can print logs inside the training or evaluation loop, or use python debugger.
 ```
 
 ![Workflow within a machine learningsystem](../img/ch03/workflow.pdf)

chapter_programming_model/Neural_Network_Programming.md

@@ -50,11 +50,11 @@ sequential data. Code `ch02/code2.3.1` shows some examples of NN Layers in Pytor
 **ch02/code2.3.1**
 ```python
 fc_layer = nn.Linear(16, 5) # A fully connected layer with 16 input features and 5 output features
-    relu_layer = nn.ReLU() # A ReLU activation layer
-    conv_layer = nn.Conv2d(3, 16, 3, padding=1) # A convolutional layer with 3 input channels, 16 output channels, and a 3x3 kernel
-    dropout_layer = nn.Dropout(0.2) # A dropout layer with 20% dropout rate
-    batch_norm_layer = nn.BatchNorm2d(16) # A batch normalization layer with 16 channels
-    layers = nn.Sequential(conv_layer, batch_norm_layer, relu_layer, fc_layer, dropout_layer) # A sequential container to combine layers
+relu_layer = nn.ReLU() # A ReLU activation layer
+conv_layer = nn.Conv2d(3, 16, 3, padding=1) # A convolutional layer with 3 input channels, 16 output channels, and a 3x3 kernel
+dropout_layer = nn.Dropout(0.2) # A dropout layer with 20% dropout rate
+batch_norm_layer = nn.BatchNorm2d(16) # A batch normalization layer with 16 channels
+layers = nn.Sequential(conv_layer, batch_norm_layer, relu_layer, fc_layer, dropout_layer) # A sequential container to combine layers
 ```
 
 In tasks related to natural language processing, the
@@ -81,21 +81,21 @@ and `torch.nn.Module` in PyTorch. Code
 **ch02/code2.3.2**
 ```python
 class MLP(nn.Module):
-    def __init__(self, input_size, hidden_size, num_classes, dropout_rate=0.5):
-        super(MLP, self).__init__()
-        self.fc1 = nn.Linear(input_size, hidden_size)
-        self.bn1 = nn.BatchNorm1d(hidden_size)
-        self.relu = nn.ReLU()
-        self.dropout = nn.Dropout(dropout_rate)
-        self.fc2 = nn.Linear(hidden_size, num_classes)
-    
-    def forward(self, x):
-        out = self.fc1(x)
-        out = self.bn1(out)
-        out = self.relu(out)
-        out = self.dropout(out)
-        out = self.fc2(out)
-        return out
+def __init__(self, input_size, hidden_size, num_classes, dropout_rate=0.5):
+    super(MLP, self).__init__()
+    self.fc1 = nn.Linear(input_size, hidden_size)
+    self.bn1 = nn.BatchNorm1d(hidden_size)
+    self.relu = nn.ReLU()
+    self.dropout = nn.Dropout(dropout_rate)
+    self.fc2 = nn.Linear(hidden_size, num_classes)
+
+def forward(self, x):
+    out = self.fc1(x)
+    out = self.bn1(out)
+    out = self.relu(out)
+    out = self.dropout(out)
+    out = self.fc2(out)
+    return out
 ```
 
 Figure :numref:`ch03/model_build` demonstrates the intricate process of