# Install PyTorch using pip
pip install torch==1.8.0+cu113 torchaudio===0.8.2 -f https://download.pytorch.org/whl/torch_stable.html # This command uses pip to install PyTorch version 1.8.0 with CUDA 11.3 support and torchaudio version 0.8.2 from the PyTorch website.

# Install PyTorch using conda (recommended)
conda install pytorch=1.8.0 torchvision cudatoolkit=11.3 -c pytorch # This command uses conda to install PyTorch version 1.8.0 with torchvision and CUDA 11.3 support from the PyTorch channel. This is the recommended method for installation.

# Import necessary libraries
import torch # Importing the PyTorch library
from torch.nn import Linear, ReLU # Importing specific modules from the torch.nn library
from torch.utils.tensorboard import SummaryWriter # Importing the SummaryWriter module from the torch.utils.tensorboard library

# Create a simple neural network
# Define the input size, hidden layer size, and output size
input_size = 10 # Input size of the neural network
hidden_size = 20 # Hidden layer size of the neural network
output_size = 5 # Output size of the neural network

# Create a linear layer with input size and output size
linear_layer = Linear(input_size, output_size) # Creating a linear layer with input and output size

# Create a ReLU activation function
relu = ReLU() # Creating a ReLU activation function

# Create a tensorboard writer for visualization
writer = SummaryWriter() # Creating a tensorboard writer for visualization

# Generate random input data
input_data = torch.randn(100, input_size) # Generating random input data with 100 rows and input size columns

# Pass the input data through the linear layer
output = linear_layer(input_data) # Passing the input data through the linear layer to get the output

# Apply ReLU activation function to the output
output = relu(output) # Applying ReLU activation function to the output

# Write the output to tensorboard for visualization
writer.add_graph(linear_layer, input_data) # Writing the output to tensorboard for visualization

# Close the tensorboard writer
writer.close() # Closing the tensorboard writer

# Define the neural network model
class Net(torch.nn.Module):
    # Initialize the model
    def __init__(self):
        super().__init__() # Call the parent class constructor
        self.fc1 = Linear(784, 256) # Define the first fully connected layer with 784 input neurons and 256 output neurons
        self.relu = ReLU() # Define the ReLU activation function
        self.fc2 = Linear(256, 10) # Define the second fully connected layer with 256 input neurons and 10 output neurons for the 10 digits in MNIST dataset

    # Define the forward pass of the model
    def forward(self, x):
        x = self.fc1(x) # Pass the input through the first fully connected layer
        x = self.relu(x) # Apply ReLU activation function
        x = self.fc2(x) # Pass the output of the first layer through the second fully connected layer
        return x # Return the output of the model

# Example code for loading MNIST dataset using PyTorch's built-in functions
# Import necessary libraries
from torchvision import datasets, transforms

# Define preprocessing function to normalize pixel values between 0 and 1
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5), (0.5))])
# Compose is used to chain multiple transforms together, in this case, ToTensor() and Normalize()
# ToTensor() converts the image data into a PyTorch tensor
# Normalize() normalizes the pixel values between -1 and 1, with mean and standard deviation of 0.5

# Load MNIST dataset using the defined preprocessing function
train_data = datasets.MNIST('../data', download=True, transform=transform)
test_data = datasets.MNIST('../data', download=True, transform=transform)
# datasets.MNIST() is used to load the MNIST dataset from the specified directory
# download=True ensures that the dataset is downloaded if it is not already present in the specified directory
# transform=transform applies the defined preprocessing function to the dataset

# Define training and testing functions to load data into PyTorch's DataLoader class for faster processing
def train(dataloader):
    model.train() # Sets the model to training mode
    loss_fn = torch.nn.CrossEntropyLoss() # Defines the loss function to be used, in this case, CrossEntropyLoss
    optimizer = torch.optim.Adam(model.parameters(), lr=0.01) # Defines the optimizer to be used, in this case, Adam with a learning rate of 0.01
    # model.parameters() returns a list of all the parameters of the model, which are then passed to the optimizer for updating during training

    for batch, (x, y) in enumerate(dataloader):
        x = x.view(-1, 784).float() # Reshape input data to match model's expected format and convert it to float32 for faster processing
        # x.view(-1, 784) reshapes the input data to have a batch size of -1 (which is inferred based on the input data) and 784 features (28x28 pixels)
        # .float() converts the data to float32 for faster processing
        optimizer.zero_grad() # Clears the gradients before computing them during backpropagation
        # Gradients are accumulated during each iteration, so it is necessary to clear them before each iteration to avoid incorrect updates

        output = model(x) # Passes the input data to the model and stores the output in a variable called 'output'
        loss = loss_fn(output, y) # Computes the loss using the defined loss function and stores it in a variable called 'loss'
        # The loss is calculated by comparing the output of the model with the actual labels (y) using the CrossEntropyLoss function
        # This loss is used to update the parameters of the model during backpropagation

# Example code for saving PyTorch models to disk using torch.save() function

# Define path where you want to save the model
output_path = './models/'

# Load pretrained model and convert it into a dictionary format that can be saved to disk
state_dict = model.state_dict() # state_dict is a dictionary that contains the parameters and buffers of the model

# Save the model using torch.save() function
torch.save(state_dict, output_path + 'model.pth') # torch.save() function saves the state_dict to the specified path, in this case, './models/model.pth'