In this article, I will explain the basic usage of PyTorch for deep learning and the training process of machine learning models in detail.
From the basics of deep learning to advanced topics, I aim to help you learn systematically with practical examples.
1. What is PyTorch?
PyTorch is an open-source machine learning library based on Python, primarily used for research and development in deep learning.
PyTorch supports flexible neural network building and powerful GPU acceleration, enabling researchers and engineers to experiment and optimize quickly.
2. Installing PyTorch
To install PyTorch, you first need to have Python installed.
Then, you can use the following command to install PyTorch via pip:
pip install torch torchvision torchaudio
3. Basic Concepts of Deep Learning
Deep learning is a field of machine learning that utilizes artificial neural networks to automatically learn features from data.
The main concepts we will cover are as follows:
- Neural Network
- Backpropagation
- Loss Function
- Optimization
3.1 Neural Network
A neural network consists of an input layer, hidden layers, and an output layer.
Each layer is composed of nodes, and the connections between nodes have weights.
These weights are updated through the learning process.
3.2 Backpropagation
Backpropagation is a technique for adjusting weights by calculating the gradient from the loss function.
This helps improve the model’s predictions.
3.3 Loss Function
The loss function measures the difference between the model’s predictions and the actual values.
This function evaluates the model’s performance and indicates the directions for improvement during the optimization process.
3.4 Optimization
Optimization is the process of minimizing the loss function,
applying lightweight architectures and efficient learning techniques to improve the model’s accuracy.
4. Building a Basic Neural Network Model with PyTorch
Let’s actually build a simple neural network model using PyTorch.
4.1 Preparing the Dataset
First, we will create a model to classify handwritten digits using the MNIST dataset.
The MNIST dataset contains images of digits from 0 to 9.
We can use the datasets provided by torchvision in PyTorch.
import torch
import torchvision
import torchvision.transforms as transforms
# Load MNIST dataset
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)
testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)
4.2 Defining the Neural Network Model
The process of defining a neural network model is as follows:
import torch.nn as nn
import torch.nn.functional as F
# Define the neural network
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(28 * 28, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = x.view(-1, 28 * 28) # Flatten the input
x = F.relu(self.fc1(x)) # Apply ReLU activation
x = self.fc2(x) # Output layer
return x
4.3 Setting Up the Loss Function and Optimizer
We set up the loss function and optimizer for training the model:
import torch.optim as optim
# Create the model
model = Net()
# Set the loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
4.4 Training the Model
Now it’s time to train the model. We will set the number of epochs and write the code to update the model’s weights for each batch:
for epoch in range(5): # Train for 5 epochs
for inputs, labels in trainloader:
optimizer.zero_grad() # Initialize gradients
outputs = model(inputs) # Model prediction
loss = criterion(outputs, labels) # Calculate loss
loss.backward() # Compute gradients
optimizer.step() # Update weights
print(f'Epoch {epoch + 1}, Loss: {loss.item():.4f}')
4.5 Evaluating the Model
Let’s evaluate how well the model has learned.
We can calculate the accuracy using the test dataset:
correct = 0
total = 0
with torch.no_grad():
for inputs, labels in testloader:
outputs = model(inputs)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print(f'Accuracy: {100 * correct / total:.2f}%')
5. Conclusion
In this article, we explored the basic concepts of deep learning and the training process of models using PyTorch.
We learned how to build a simple neural network model and how to confirm the model’s performance through training and evaluation.
To advance further, it would be beneficial to study deep learning architectures, various optimization techniques, and hyperparameter tuning.