Brief History and Motivation Behind NST

Neural Style Transfer (NST) is a technique that emerged from the intersection of deep learning and computer vision. It gained significant attention in 2015 when researchers Leon A. Gatys, Alexander S. Ecker, and Matthias Bethge introduced a groundbreaking paper titled “A Neural Algorithm of Artistic Style.” This paper showcased how convolutional neural networks (CNNs), which are typically used for image recognition tasks, could be repurposed to create stunning artistic images by blending the content of one image with the style of another.

You can read the published paper here.

What is Neural Style Transfer

Neural Style Transfer is a deep learning technique that manipulates an image by merging the content of one image with the artistic style of another. Imagine taking a photograph of a cityscape and transforming it to look as if it were painted by Vincent van Gogh or Pablo Picasso. This is achieved by leveraging the power of CNNs to separately extract and recombine the content and style features of images.

The process works by first extracting the content features from the target image and the style features from the reference style image. Through an optimization process, NST adjusts a third image, called the generated image, to minimize the differences in content and style between the target and reference images respectively. The result is an image that maintains the structural integrity of the content image while adopting the stylistic elements of the reference image.

Understanding Content and Style in Images

Definition of Content and Style in the Context of Images

In the context of image processing, “content” and “style” refer to two distinct aspects of an image.

• Content: This pertains to the objects, structures, and the overall layout within an image. For example, in a photograph of a cityscape, the buildings, streets, and skyline represent the content. It captures the essence and the primary subjects of the image.
• Style: Style, on the other hand, encompasses the artistic elements of an image, such as colors, textures, brushstrokes, and patterns. In a painting, the style is what defines the artist’s unique approach, be it the swirling strokes of Van Gogh or the cubist forms of Picasso.

How Humans Perceive Content and Style Differently

We humans have an innate ability to distinguish between content and style when viewing an image. This ability allows us to recognize the same scene (content) even when it is rendered in different artistic styles. For instance, a picture of a tree drawn in a cartoonish manner or painted realistically is still identifiable as a tree. Our brains can separate the structural components (content) from the aesthetic elements (style) seamlessly.

The Role of Convolutional Neural Networks (CNNs) in Distinguishing Content from Style

Convolutional Neural Networks (CNNs) play a pivotal role in the process of Neural Style Transfer by mimicking this human ability to separate content and style. CNNs are a class of deep learning models particularly adept at processing visual data. They are composed of multiple layers that extract features from images in a hierarchical manner.

• Content Extraction: In the context of NST, deeper layers of a CNN are used to capture the content of an image. These layers respond to high-level features such as shapes and structures. By using these deeper layers, NST can effectively represent the primary subjects of an image without focusing on fine details.
• Style Extraction: The style of an image is captured using the responses from shallower layers of the CNN. These layers detect lower-level features like edges, textures, and colors. By examining the patterns of activation across these layers, NST can encode the stylistic elements of an image.

The NST process involves optimizing a new image to have similar content representations (from the deeper layers) to the content image and similar style representations (from the shallower layers) to the style image. This optimization is done by minimizing a loss function that quantifies the differences in content and style between the generated image and the target images.

Implementing Neural Style Transfer in PyT🔥rch

Step 1: Install and import required packages

!pip install torch torchvision torch_snippets

# import the required packages
import torch
import torch.nn.functional as F
import torchvision.transforms as T
from torch_snippets import *

# set the device
device = "cuda:0" if torch.cuda.is_available() else "cpu"
print(device)

Step 2: Load and preprocess the images

# Url for the `style image`
!wget https://res.cloudinary.com/ezmonydevcloud/image/upload/v1710325675/turning-pattern.png

# Url for the `content image`
!wget https://res.cloudinary.com/ezmonydevcloud/image/upload/v1710322208/thomas-shelby.jpg

preprocess = T.Compose([
    T.ToTensor(),
    # we'll use mean and std used for VGG models
    T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), 
    T.Lambda(lambda x: x.mul_(255))
])

postprocess = T.Compose([
    T.Lambda(lambda x: x.mul(1./255)),
    T.Normalize(mean=[-0.485/0.229, -0.456/0.224, -0.406/0.225], std=[1/0.229, 1/0.224, 1/0.225]),
])

Explanation

• Preprocessing: Prepares the image data to match the distribution of the data used to train the VGG model. This involves normalizing the image tensor to have a specific mean and standard deviation, ensuring consistency in the input data.
• Postprocessing: Reverts the transformations applied during preprocessing, bringing the image data back to its original form or a form suitable for further use, such as visualization.

from PIL import Image
import matplotlib.pyplot as plt

imgs = [Image.open(path).resize((512, 512)).convert('RGB') for path in ['turning-pattern.png', 'thomas-shelby.jpg']]
style_image, content_image = [preprocess(img).to(device)[None] for img in imgs]

# Modify content image with `require_grad=True`
opt_img = content_image.data.clone()
opt_img.requires_grad = True

# Display the images
fig, axes = plt.subplots(nrows=1, ncols=len(imgs), figsize=(len(imgs) * 5, 5))

for idx in range(len(imgs)):
    axes[idx].imshow(imgs[idx])
    axes[idx].axis('off') # do this, if you want to hide the axis
    
plt.show()

Step 3: Define the model class, vgg19_modified

from torchvision.models import vgg19, VGG19_Weights

class vgg19_modified(nn.Module):
    def __init__(self):
        super().__init__()
        features = list(vgg19(weights=VGG19_Weights.IMAGENET1K_V1).features)
        self.features = nn.ModuleList(features).eval()
        
    # Define the forward method, which takes the list of layers and returns the features corresponding to each layer
    def forward(self, x, layers=[]):
        order = np.argsort(layers)
        _results, results = [], []
        for ix, model in enumerate(self.features):
            x = model(x)
            if ix in layers: _results.append(x)
        for o in order: results.append(_results[o])
        return results if layers is not [] else x
    
# Define the model object
vgg = vgg19_modified().to(device)

This code defines a modified VGG19 model that allows extraction of features from specific layers. By creating a custom vgg19_modified class, it loads the pre-trained VGG19, converts its feature layers to a ModuleList, and enables the forward method to return features from specified layers.

Step 4: Implementing loss functions

Content Loss Function

The content loss function is used to ensure that the generated image retains the primary subjects and structure of the content image. It measures how much the high-level features of the generated image differ from those of the content image.

In practice, this is achieved by passing both the content image and the generated image through a pre-trained Convolutional Neural Network (CNN) and extracting the feature maps from a specific layer. These feature maps represent the high-level content of the images.

The content loss Lcontent​ is calculated as the mean squared error (MSE) between the feature representations of the content image P and the generated image G:

where:

• Fl is the feature map of the generated image from layer l.
• Pl is the feature map of the content image from layer l.
• i and j index the elements in the feature maps.

This loss function ensures that the generated image G has similar high-level features as the content image P, preserving the overall structure and objects in the scene.

Style Loss Function

The style loss function is designed to capture the stylistic elements of the style image and transfer them to the generated image. It measures how well the textures, colors, and patterns of the style image are replicated in the generated image.

To achieve this, the style of an image is represented using the Gram matrix, which captures the correlations between different feature maps in a layer of the CNN. The Gram matrix Gl for a layer l is defined as:​

The style loss Lstyle​ is calculated as the MSE between the Gram matrices of the style image S and the generated image P:

This loss function ensures that the generated image P replicates the stylistic features of the style image S, including textures and patterns.

Combining Content and Style Losses

In Neural Style Transfer, the total loss function is a weighted sum of the content loss and the style loss:

Ltotal​= αLcontent​+βLstyle​

where:

• α and β are weights that control the relative importance of content and style.

By minimizing this total loss function, the NST algorithm generates an image that balances the structure of the content image with the artistic style of the style image.

Define the gram matrix module

class GramMatrix(nn.Module):
    def forward(self, input):
        b,c,h,w = input.size()
        feat = input.view(b, c, h*w)
        G = feat@feat.transpose(1,2)
        G.div_(h*w)
        return G
    
# Define the gram matrix's corresponding MSE Loss, GramMSELoss
class GramMSELoss(nn.Module):
    def forward(self, input, target):
        out = F.mse_loss(GramMatrix()(input), target)
        return(out)

Specify the layer that define content loss and style loss

style_layers = [0, 5, 10, 19, 28]
content_layers = [21]
loss_layers = style_layers + content_layers

# Define the loss function for content and style loss values
loss_fns = [GramMSELoss()] * len(style_layers) + [nn.MSELoss()] * len(content_layers)
loss_fns = [loss_fn.to(device) for loss_fn in loss_fns]

# Define the weights associated with content and style loss
style_weights = [1000/n**2 for n in [64,128,256,512,512]]
content_weights = [1]
weights = style_weights + content_weights

We need to manipulate our image such that the style of the target image resembles style_image as much as possible. Hence we compute the style_targets values of style_image by computing GramMatrix of features obtained from a few chosen layers of VGG. Since the overall content should be preserved, we choose the content_layer variable at which we compute the raw features from VGG.

style_targets = [GramMatrix()(A).detach() for A in vgg(style_image, style_layers)]
content_targets = [A.detach() for A in vgg(content_image, content_layers)]
targets = style_targets + content_targets

Step 5: Define optimizer and number of iterations

Even though we could have used Adam or any other optimizer, LBFGS is an optimizer that has been observed to work best in deterministic scenarios. Additionally, since we are dealing with exactly one image, there is nothing random. Many experiments have revealed that LBFGS converges faster and to lower losses in neural transfer settings, so we will use this optimizer

max_iters = 1000
optimizer = optim.LBFGS([opt_img])
log = Report(max_iters)

Step 6: Train the model

Perform the optimization. In deterministic scenarios where we are iterating on the same tensor again and again, we can wrap the optimizer step as a function with zero arguments and repeatedly call it, as shown here.

iters = 0
while iters < max_iters:
    def closure():
        global iters
        iters += 1
        optimizer.zero_grad()
        out = vgg(opt_img, loss_layers)
        layer_losses = [weights[a]*loss_fns[a](A,targets[a]) \
        for a,A in enumerate(out)]
        loss = sum(layer_losses)
        loss.backward()
        log.record(pos=iters, loss=loss, end='\r')
        return loss
    optimizer.step(closure)

# Plot the variation in the loss
log.plot(log=True)

# Plot the image with combination of content and style images
out_img = postprocess(opt_img[0]).permute(1,2,0)
show(out_img)

As you can see our model after the training is successfully able to blend the style with the content of original image. You could try this out on your own images to test it out how it’s performing on those. You could also try out tweaking some parameters or training it for longer iterations, if you are not satisfied with the final result.

You could get the code on my kaggle notebook.

You could also try checking out my other blog posts:

• What is early stopping in deep learning?
• Reinforcement learning 101: Best introduction for beginners
• Genetic algorithm implementation: Code from scratch in Python

See you in future in a different dimension (maybe …)

Genetic algorithms are a class of optimization algorithms inspired by the process of natural selection. They are used to find approximate solutions to optimization and search problems. GAs are based on the principles of genetics and evolution, such as inheritance, mutation, selection, and crossover (recombination).

How Genetic Algorithms Work

Genetic Algorithms work by mimicking the process of natural selection and evolution to find approximate solutions to optimization and search problems. Here’s a step-by-step explanation of how they work:

Step 1️⃣: Initialization

Genetic algorithms begin by creating a population of random candidate solutions, known as chromosomes, to represent potential solutions to the problem.

In above code, each chromosome is a binary representation of an integer ranging between 0–255. As closer their value is to a threshold (we will define) as better that chromose is for our current scenario.

Step 2️⃣: Selection

The fitness of each chromosome is evaluated based on how well it solves the problem. The fittest chromosomes are selected to serve as parents for the next generation.

As closer the fitness score of a chromosome is to 255 as likely they would be selected to serve as parents for the up coming generations (and its only possible when their integer representation is close to threshold).

Step 3️⃣: Crossover

Selected parents are used to create new offspring through a process called crossover, where genetic material from two parents is combined to produce one or more offspring.

New born childs/chromosomes would have combined genes of both parents as we see in any human child.

Step 4️⃣: Mutation

To maintain genetic diversity in the population, random changes, or mutations, are introduced to the offspring’s genetic material.

Mutation makes sure that each child would maintain diversity from each other and parents altogether.

Step 5️⃣: Replacement

The least fit members of the population are replaced by the new offspring, ensuring that the population evolves towards better solutions over time.

Step 6️⃣: Termination

The process is repeated for multiple generations until a termination condition is met, such as finding an acceptable solution or reaching a maximum number of generations.

In most scenarios you would notice the best chromosome until the last generation has reached the best fitness score.

Genetic algorithms are widely used in optimization and search problems across various domains. They are particularly useful when the search space is large and complex.

You would see genetic algorithms (along with neural networks) widely being used in developing ai agents to play various games like flappy bird, snake, ping pong and many other single & multi player games.

In my next blog, I will guide you through how to use neural networks along with genetic algorithms to create such agents. This technique is called NEAT (NeuroEvolution of Augmenting Topologies). I think you might have heard about it before, if you have dived well enough in the field of reinforcement learning.

🧑🏻‍💻 Code your own genetic algorithm from scratch using python

👨🏻‍🔬 Genetic algorithms explained (but this time visually)

If you’d like to learn more about genetic algorithms or reinforcement learning in general, then don’t forget to follow my page. See ya’ 👋🏻

Reinforcement learning is a framework for solving control tasks (also called decision problems) by building agents that learn from the environment by interacting with it through trial and error and receiving rewards (positive or negative) as unique feedback.

I know this definition can be intimidating at first, so I will try to explain this definition to you with a real world example:

• Imagine putting your little brother in front of a video game he never played, giving him a controller, and leaving him alone.

• Your brother will interact with the environment (the video game) by pressing the right button (action). He got a coin, that’s a +1 reward. It’s positive, he just understood that in this game he must get the coins.

• But then, he presses the right button again and he touches an enemy. He just died, so that’s a -1 reward.

By interacting with his environment through trial and error, your little brother understands that he needs to get coins in this environment but avoid the enemies.

Without any supervision, the child will get better and better at playing the game.

That’s how humans and animals learn, through interaction. Reinforcement Learning is just a computational approach of learning from actions.

The reward hypothesis: the central idea of Reinforcement Learning

⇒ Why is the goal of the agent to maximize the expected return?

Because RL is based on the reward hypothesis, which is that all goals can be described as the maximization of the expected return (expected cumulative reward).

That’s why in Reinforcement Learning, to have the best behavior, we aim to learn to take actions that maximize the expected cumulative reward.

THE RL PROCESS:

• Our Agent receives state S0​ from the Environment — we receive the first frame of our game (Environment).
• Based on that state S0​, the Agent takes action A0 — our Agent will move to the right.
• The environment goes to a new state S1 — new frame.
• The environment gives some reward R1​ to the Agent — we’re not dead (Positive Reward +1).

This RL loop outputs a sequence of state, action, reward and next state.

Now time has come for you to understand all the common jargons used in Reinforcement Learning world. You can narrow your focus on screen now.

Observations/States Space:

Observations/States are the information our agent gets from the environment. In the case of a video game, it can be a frame (a screenshot). In the case of the trading agent, it can be the value of a certain stock, etc.

There is a differentiation to make between observation and state, however:

• State s: is a complete description of the state of the world (there is no hidden information). In a fully observed environment.

• Observation o: is a partial description of the state. In a partially observed environment.

In Super Mario Bros, we are in a partially observed environment. We receive an observation since we only see a part of the level.

Action Space

The Action space is the set of all possible actions in an environment.

The actions can come from a discrete or continuous space:

• Discrete space: the number of possible actions is finite.

Again, in Super Mario Bros, we have a finite set of actions since we have only 4 directions.

• Continuous space: the number of possible actions is infinite.

Rewards and the Discounting

The reward is fundamental in RL because it’s the only feedback for the agent. Thanks to it, our agent knows if the action taken was good or not.

The cumulative reward at each time step t can be written as:

However, in reality, we can’t just add them like that. The rewards that come sooner (at the beginning of the game) are more likely to happen since they are more predictable than the long-term future reward.

Let’s say your agent is this tiny mouse that can move one tile each time step, and your opponent is the cat (that can move too). The mouse’s goal is to eat the maximum amount of cheese before being eaten by the cat.

As we can see in the diagram, it’s more probable to eat the cheese near us than the cheese close to the cat (the closer we are to the cat, the more dangerous it is).

Consequently, the reward near the cat, even if it is bigger (more cheese), will be more discounted since we’re not really sure we’ll be able to eat it.

To discount the rewards, we proceed like this:

1. We define a discount rate called gamma. It must be between 0 and 1. Most of the time between 0.95 and 0.99.

• The larger the gamma, the smaller the discount. This means our agent cares more about the long-term reward.
• On the other hand, the smaller the gamma, the bigger the discount. This means our agent cares more about the short term reward (the nearest cheese).

2. Then, each reward will be discounted by gamma to the exponent of the time step. As the time step increases, the cat gets closer to us, so the future reward is less and less likely to happen.

Type of Tasks

A task is an instance of a Reinforcement Learning problem. We can have two types of tasks: episodic and continuing.

Episodic task

In this case, we have a starting point and an ending point (a terminal state). This creates an episode: a list of States, Actions, Rewards, and new States.

For instance, think about Super Mario Bros: an episode begin at the launch of a new Mario Level and ends when you’re killed or you reached the end of the level.

Continuing tasks

These are tasks that continue forever (no terminal state). In this case, the agent must learn how to choose the best actions and simultaneously interact with the environment.

For instance, an agent that does automated stock trading. For this task, there is no starting point and terminal state. The agent keeps running until we decide to stop it.

The Exploration/Exploitation trade-off

Finally, before looking at the different methods to solve Reinforcement Learning problems, we must cover one more very important topic: the exploration/exploitation trade-off.

• Exploration is exploring the environment by trying random actions in order to find more information about the environment.
• Exploitation is exploiting known information to maximize the reward.

Remember, the goal of our RL agent is to maximize the expected cumulative reward. However, we can fall into a common trap.

Let’s take an example:

In this game, our mouse can have an infinite amount of small cheese (+1 each). But at the top of the maze, there is a gigantic sum of cheese (+1000).

However, if we only focus on exploitation, our agent will never reach the gigantic sum of cheese. Instead, it will only exploit the nearest source of rewards, even if this source is small (exploitation).

But if our agent does a little bit of exploration, it can discover the big reward (the pile of big cheese).

This is what we call the exploration/exploitation trade-off. We need to balance how much we explore the environment and how much we exploit what we know about the environment.

Therefore, we must define a rule that helps to handle this trade-off. We’ll see the different ways to handle it in the future units.

If it’s still confusing, think of a real problem: the choice of picking a restaurant:

• Exploitation: You go to the same one that you know is good every day and take the risk to miss another better restaurant.
• Exploration: Try restaurants you never went to before, with the risk of having a bad experience but the probable opportunity of a fantastic experience.

Two main approaches for solving RL problems

Now that we learned the RL framework, how do we solve the RL problem?

In other words, how do we build an RL agent that can select the actions that maximize its expected cumulative reward?

The Policy π: the agent’s brain

The Policy π is the brain of our Agent, it’s the function that tells us what action to take given the state we are in. So it defines the agent’s behavior at a given time.

This Policy is the function we want to learn, our goal is to find the optimal policy π*, the policy that maximizes expected return when the agent acts according to it. We find this π* through training.

There are two approaches to train our agent to find this optimal policy π*:

• Directly, by teaching the agent to learn which action to take, given the current state: Policy-Based Methods.
• Indirectly, teach the agent to learn which state is more valuable and then take the action that leads to the more valuable states: Value-Based Methods.

Policy-Based Methods

In Policy-Based methods, we learn a policy function directly.

This function will define a mapping from each state to the best corresponding action. Alternatively, it could define a probability distribution over the set of possible actions at that state.

We have two types of policies:

• Deterministic: a policy at a given state will always return the same action.

• Stochastic: outputs a probability distribution over actions.

Value-based methods

In value-based methods, instead of learning a policy function, we learn a value function that maps a state to the expected value of being at that state.

The value of a state is the expected discounted return the agent can get if it starts in that state, and then acts according to our policy.

“Act according to our policy” just means that our policy is “going to the state with the highest value”.

Here we see that our value function defined values for each possible state.

Thanks to our value function, at each step our policy will select the state with the biggest value defined by the value function: -7, then -6, then -5 (and so on) to attain the goal.

I understand that some of this might have been a bit confusing, but I don’t want you to feel overwhelmed. Let’s clear things up together! Here’s a simple breakdown of everything we’ve talked about.

• Reinforcement Learning is all about maximizing the cumalative reward/expected return by optimizing the Policy π (the agent’s brain).
• You could also understand it like this: when training neural networks, our goal has to minimize the loss function by optimizing the weights.
• To optimize the policy, we have two options. First, by using policy based methods which optimize the policy directly. And second, value based methods which indirectly helps optimizing the policy.
• And ultimately all reinforcement learning revolves around agent, states, actions and rewards.

By now, I hope you’ve grasped the essence of reinforcement learning and even picked up on some of the jargon commonly used in this field. If you’re eager to dive deeper into the world of reinforcement learning, here are some resources to help you along the way 👇

Books:

• Reinforcement Learning: An Introduction
• Grokking Deep Reinforcement Learning

These two are my personal best books. First book, explains reinforcement learning theories whereas second books teaches you to code algorithms from scratch to solidify your knowledge.

Additional course you could take (not a book): Deep Reinforcement Learning course by Hugging face community.

Note: This blog is highly inspired by the introduction chapeter of the above course. If you liked this blog, I would highly recommend you to take this course.

Youtube Playlists:

• Reinforcement Learning course by CIS 522
• Reinforcement Learning 101 by CodeEmporium
• Reinforcement Learning series by DeepMind x UCL

Note: I haven’t watched many youtube videos on reinforcement learning, these are the best playlists I’ve come around so far. You could also search for better tutorials on yourselves.

If you’ve come to the end and liked reading this blog, you could show me your appreciation by giving me round of applause. And yeah definitely, you could follow me for more reinforcement learning related blogs (or in general for Deep Learning)

Early stopping is a technique used while training neural networks to prevent the model from overfitting. Before understanding what actually early stopping is, you must know what is overfitting.

What is Overfitting?

Overfitting is a common problem in machine learning and deep learning where a model learns the training data too well. It happens when the model captures not only the underlying patterns in the data but also the noise or random fluctuations. As a result, the model performs exceptionally well on the training data but poorly on unseen data (test data or real-world data).

Causes of Overfitting:

1. Complex Model: Using a model with too many parameters relative to the number of observations can lead to overfitting. The model might capture the noise in the training data, making it perform poorly on new data.
2. Insufficient Training Data: If the dataset is too small, the model might not have enough examples to learn the underlying patterns effectively. It might end up learning the noise in the data.
3. Lack of Regularization: Regularization techniques, such as L1 and L2 regularization, add a penalty to the loss function to prevent the model from fitting the training data too closely. Without these, the model might overfit.

There are few more causes that could lead to overfitting including data leakage and overly optimisic evaluation metrics.

Preventing the model from overfitting involves following techniques:

1. Use More Data
2. Regularization
3. Dropout
4. Early Stopping
5. Data Augmentation

And there are still many other ways to prevent overfitting. But in this blog, I would specifically explain about ‘Early Stopping’.

What is Early Stopping?

Early stopping is a form of regularization used to prevent overfitting in machine learning and deep learning models. It involves stopping the training process before the model starts to overfit. The idea is to monitor the model’s performance on a validation set during the training process and stop training when the performance starts to degrade, which is an indication that the model is beginning to overfit the training data.

How Early Stopping Works

1. Validation Set: During training, a portion of the training data is set aside as a validation set. This set is used to evaluate the model’s performance at each epoch (iteration over the entire dataset).
2. Performance Monitoring: The model’s performance on the validation set is monitored at each epoch. Common metrics used for this purpose include accuracy, loss, or any other metric relevant to the problem at hand.
3. Early Stopping Criterion: If the performance on the validation set starts to degrade (e.g., the loss increases or the accuracy decreases), it’s an indication that the model is beginning to overfit the training data. At this point, early stopping is triggered, and the training process is halted.
4. Model Selection: Since the training is stopped before overfitting occurs, the model at the point of early stopping is typically the best model, as it has not yet learned the noise in the training data

How does early stopping works in the code

To be honest, this is all there is to early stopping. Before finishing this blog, I would like to show you, how to implement early stopping in PyTorch.

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# Define your model, loss function, and optimizer
model = ...
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# Load your data
train_data = datasets.MNIST(...)
train_loader = DataLoader(train_data, batch_size=64, shuffle=True)

# Early stopping parameters
patience = 5 # Number of epochs to wait before stopping
min_delta = 0.01 # Minimum change in loss to qualify as an improvement
patience_counter = 0
best_loss = float('inf')

for epoch in range(100): # Maximum number of epochs
    running_loss = 0.0
    for inputs, labels in train_loader:
        # training logic here

    # Validation
    val_loss = ... # Calculate validation loss

    # Check for improvement
    if val_loss < best_loss - min_delta:
        best_loss = val_loss
        patience_counter = 0
    else:
        patience_counter += 1
        if patience_counter >= patience:
            print(f"Early stopping at epoch {epoch}")
            break

print(f"Best validation loss: {best_loss}")

In this example, we’re using a simple model and a placeholder for the validation loss calculation. You’ll need to replace this with your actual validation loss calculation. The key part is the early stopping logic, which checks if the validation loss has improved by at least min_delta from the best loss seen so far. If not, it increments paitence_counter. If patience_counter reaches the patience value, training is stopped.

Remember, early stopping is a form of regularization and is particularly useful when you have a validation set to monitor the model’s performance on unseen data.

If you’ve liked the explanation, you could show your appreciation by giving me a round of applause. And if you would like to understand other ways to prevent overfitting, you could comment below 👇