Select Page
diffusion model
Listen to the article
What is Chainlink VRF

With the widespread recognition of ChatGPT, the rise of generative AI has been truly remarkable. In this landscape filled with emerging generative AI models, one category has consistently stood out thanks to their exceptional performance – diffusion models. These innovative models, underpinned by principles of Gaussian mathematics, variance, differential equations, and generative sequences, are reshaping our approach to complex generative AI tasks. If these terms sound a bit technical, don’t worry – we’ll demystify the jargon shortly.

Diffusion models are making waves in the AI community, with companies like Nvidia, Google, Adobe, and OpenAI spotlighting their transformative capabilities. Recent examples, such as DALL.E 2, Stable Diffusion, and Midjourney, have taken the internet by storm. These models can turn a simple text prompt into stunningly realistic images, showcasing the incredible potential of AI to enhance creativity and drive innovation.

As these models continue to gain traction, learning how to train them becomes increasingly crucial for anyone looking to stay ahead in the AI field. In this article, we’ll walk you through the intricacies of training diffusion models, providing you with insights and tools to harness their power effectively. Join us as we delve into this captivating world and explore the trends shaping the future of AI and generative technologies.

What is a diffusion model?

Diffusion models are a class of generative models designed to capture and simulate complex data distributions, making them particularly useful for tasks such as image generation, text generation, and data synthesis. Imagine a scenario where a cherished photograph slowly becomes blurred and noisy over time. The core essence of diffusion models lies in mimicking this process of degradation and then mastering the art of restoring the picture back to its original clarity.

These models introduce controlled chaos into training data by infusing it with Gaussian noise. The brilliance of the process is in then reversing this noise-infusion, bringing the data back to its pristine state. It’s like training an artist to fix a smudged painting, so by the time they’re handed a blank canvas, they can recreate masterpieces from scratch.

Having roots dating back to 2015, diffusion models, sometimes known as diffusion probabilistic models, belong to the realm of latent variable models. Picture these models as being akin to watercolor artists who observe how droplets spread (or “diffuse”) on paper. In a digital world, the process is about observing data points as they wander through a latent, or hidden, space. By becoming adept at reversing this wandering, neural networks can magically clear up images smeared with Gaussian noise.

The world of computer vision has embraced diffusion models in various forms. Three notable frameworks include the denoising diffusion probabilistic models, noise-conditioned score networks, and the science-backed stochastic differential equations. With these models in hand, tech wizards have advanced in areas like sharpening blurry images, restoring parts of missing images, enhancing image resolution, and even conjuring entirely new images.

A remarkable example of the power of diffusion models is OpenAI’s DALL-E 2. Think of it starting with a canvas filled only with randomness and chaos. With its prior training on reversing the diffusion process in real-world images, DALL-E 2 can transform this chaos into striking, natural images. Intriguingly, it employs diffusion models to bridge a text caption and its image representation, resulting in the creation of the final visual masterpiece.

Diffusion model categories

Three fundamental mathematical frameworks form the basis of diffusion models. These models work by adding noise and then removing it to generate new samples. Let’s take a closer look at each framework:

Denoising Diffusion Probabilistic Models (DDPMs)

DDPMs are a generative model primarily utilized to remove noise from visual or audio data. These models have demonstrated impressive results in various tasks related to denoising images and audio. One example of the practical application of DDPMs is in the film industry, where modern image and video processing tools are used to enhance production quality.

Noise-conditioned Score-based Generative Models (SGMs)

SGMs are a generative model that generates new samples from a specific distribution by learning an estimation score function that estimates the log density of the target distribution. This score function can be used to generate new data points from the distribution. SGMs have demonstrated similar capabilities as GANs in creating high-quality images of celebrities, and they can also aid in expanding healthcare datasets that are not easily accessible in significant amounts due to strict regulations and industry standards.

Stochastic Differential Equations (SDEs)

SDEs are a mathematical framework that describes changes in random processes over time and is commonly employed in both physics and financial markets to model fluctuations and calculate favorable prices. For example, the prices of commodities are highly volatile and subject to numerous random factors. By using SDEs, financial professionals can accurately calculate financial derivatives, such as futures contracts, to provide a sense of security.

How do diffusion models work?

Imagine having an image of a clear sunny day and slowly adding some noise to it, like a sandstorm. Over time, the image will be completely distorted, and you won’t be able to recognize the original scene. The process of adding noise is called forward diffusion.

Now, the model is trained to do the reverse process – to remove the noise from a distorted image step by step and recover the original image, which is called reverse diffusion.

In the case of the Denoising Diffusion Probabilistic Model (DDPM), this process works like this:

  • Forward diffusion: The model starts with an image and adds noise to it in small steps, making it gradually more and more distorted. This creates a series of distorted images, each one being a little more distorted than the previous one. This process is often compared to a Markov chain, where each step depends only on the previous one.
  • Reverse diffusion: The model learns to reverse the above process. It takes a distorted image and removes the noise step by step to recover the original image. The model does this by learning from a large number of examples of distorted images and their original versions.
  • Generating new images: Once the model has learned how to reverse the noise-adding process, it can generate new images. It starts with a completely distorted image (random noise) and removes the noise step by step to create a new, clear image. Since the model has learned the reverse process from real images, the new images it generates look similar to real-world scenes.
  • Improving efficiency: The process of adding and removing noise in small steps can be very time-consuming. To make it faster, the model uses a technique called the reparameterization trick, which allows it to generate distorted images at any step in one go. This reduces the number of steps needed to generate a new image and makes the process more efficient.
  • Adjusting variance: The amount of noise added at each step can be controlled by a parameter called variance. The model can use different schedules of variance over the steps, which affect the quality and diversity of the generated images. For example, a linear schedule gradually increases the variance, while a cosine schedule alternates between low and high variance.

Launch your project with LeewayHertz

Build text-to-image and image-to-image generative AI models with Stable Diffusion-like capabilities

Prominent applications of diffusion models

Diffusion models are used to handle various tasks related to digital content creation, some of which are:

High-quality video generation

Diffusion models can generate a subset of video frames to fill in missing frames, resulting in high-quality and smooth videos. Researchers have developed models like the Flexible Diffusion Model and Residual Video Diffusion to achieve this purpose. These models can also generate realistic videos by adding AI-generated frames between actual frames.

Diffusion models can help create high-quality videos by generating a subset of video frames to fill in missing frames, resulting in high-quality and smooth videos with no latency. By adding dummy frames after learning the patterns from available frames, these models can extend the FPS of a low FPS video with almost no frame loss. This can further assist deep learning-based models in generating synthetic videos from scratch that look similar to natural shots from high-end cameras. Essentially, diffusion models can improve the continuity and visual quality of videos.

Text-to-image generation

Another popular application of diffusion models is text-to-image generation, where models use input prompts to generate high-quality images. For instance, if we give a prompt saying, “parrots on a rice paddy,” the model will generate the intended output. Models like Blended Diffusion, unCLIP, and GLIDE can generate photorealistic images based on user input. Google has also developed an image generation model called Imagen, which uses a large language model to develop a deep textual understanding of input text to generate photorealistic images. Other popular image-generation tools like Midjourney, DALL·E and Stable Diffusion have also gained popularity in the field of AI.

Denoising and restoration of images and audio

In many industries, only high-quality and accurate visual and audio data are used because using data corrupted with noise leads to inaccurate analyses and interpretations. This is where diffusion models prove highly useful, as they can effectively remove noise from visual and audio data.

Diffusion models have been shown to provide impressive results in various image and audio denoising tasks. They achieve this by using estimation score functions to generate new samples from a given distribution, which can effectively remove noise from the data. This makes them valuable tools in fields like film production, healthcare and audio engineering, where high-quality data is essential.

How to train a diffusion model?

Step 1: Data preparation

Data collection: This is an important step in training a diffusion model. The data used to train the model must correctly represent the structure of the network and the connections between individuals in the population, such as their demographic information or preferences for certain types of information.

Data cleaning and pre-processing: Once the data has been collected, it must be cleaned and pre-processed to ensure that it is suitable for use in training a diffusion model. This can involve removing absent or repeating data, dealing with outliers, or transforming the data into a suitable format for training.

Data transformation: Data transformation is the final step in data preparation for diffusion model training. The data may be converted into a graph format or scaled to ensure all variables have similar ranges. The choice of data transformation will depend on the specific requirements of the diffusion model being trained and the nature of the data being used.

Step 2: Model selection

Comparison of different diffusion models in ML: Some commonly known types of diffusion models include threshold models, susceptible-infected (SI) models, and independent cascade models. The choice of a diffusion model depends on the customized requirements of the application. These can range from the size of the population or the complexity of the network structure to the type of diffusion being modeled.

Selection criteria: When selecting a diffusion model for training, focus on the accuracy of the model, the computational efficiency of the model, the interpretability of the model, and the ability of the model to handle missing data. It may also be important to consider the availability of data and the ease of assimilating the model into an existing system.

Model hyperparameters: These model parameters influence the performance and control the behavior of a diffusion model. The choice of hyperparameters will depend on the specific requirements of the application and the nature of the data being used. It is important to carefully tune the hyperparameters to ensure that the model is performing optimally.

Step 3: Model training

Splitting the data into training and test sets: The training set is used to train the model, while the test set is used to evaluate the performance of the model. It is important to ensure that the training and test sets represent the data as a whole and that they are not biased towards certain types of individuals or units.

Setting the model parameters: This step includes setting the hyperparameters discussed in a previous section, as well as setting any other model parameters required for the specific type of diffusion model being used. It is important to set the model parameters carefully so that the model is able to learn the underlying structure of the data and prevent overfitting.

Training the model: Once the data has been split and the model parameters have been set, the final step is to train the model. The training process typically involves iterating over the training set multiple times and updating the model parameters based on the model’s performance on the training set. The goal of the training process is to find a set of model parameters that accurately represent the relationships between individuals in the population and that generalize well to new data.

There are two implementations: conditional and unconditional.

The default non-conditional diffusion model is composed of a UNet with self-attention layers. We have the classic U structure with downsampling and upsampling paths. The main difference with traditional UNet is that the up and down blocks support an extra timestep argument on their forward pass. This is done by embedding the timestep linearly into the convolutions, for more details, check the file.

class UNet(nn.Module):
    def __init__(self, c_in=3, c_out=3, time_dim=256):
        self.time_dim = time_dim = DoubleConv(c_in, 64)
        self.down1 = Down(64, 128)
        self.sa1 = SelfAttention(128)
        self.down2 = Down(128, 256)
        self.sa2 = SelfAttention(256)
        self.down3 = Down(256, 256)
        self.sa3 = SelfAttention(256)
        self.bot1 = DoubleConv(256, 256)
        self.bot2 = DoubleConv(256, 256)
        self.up1 = Up(512, 128)
        self.sa4 = SelfAttention(128)
        self.up2 = Up(256, 64)
        self.sa5 = SelfAttention(64)
        self.up3 = Up(128, 64)
        self.sa6 = SelfAttention(64)
        self.outc = nn.Conv2d(64, c_out, kernel_size=1)
    def unet_forwad(self, x, t):
        "Classic UNet structure with down and up branches, self attention in between convs"
        x1 =
        x2 = self.down1(x1, t)
        x2 = self.sa1(x2)
        x3 = self.down2(x2, t)
        x3 = self.sa2(x3)
        x4 = self.down3(x3, t)
        x4 = self.sa3(x4)

        x4 = self.bot1(x4)
        x4 = self.bot2(x4)
        x = self.up1(x4, x3, t)
        x = self.sa4(x)
        x = self.up2(x, x2, t)
        x = self.sa5(x)
        x = self.up3(x, x1, t)
        x = self.sa6(x)
        output = self.outc(x)
        return output
    def forward(self, x, t):
        "Positional encoding of the timestep before the blocks"
        t = t.unsqueeze(-1)
        t = self.pos_encoding(t, self.time_dim)
        return self.unet_forwad(x, t)

The conditional model is almost identical but adds the encoding of the class label into the timestep by passing the label through an Embedding layer. It is a very simple and elegant solution.

class UNet_conditional(UNet):
    def __init__(self, c_in=3, c_out=3, time_dim=256, num_classes=None):
        super().__init__(c_in, c_out, time_dim)
        if num_classes is not None:
            self.label_emb = nn.Embedding(num_classes, time_dim)
    def forward(self, x, t, y=None):
        t = t.unsqueeze(-1)
        t = self.pos_encoding(t, self.time_dim)
        if y is not None:
            t += self.label_emb(y)
        return self.unet_forwad(x, t)

Launch your project with LeewayHertz

Build text-to-image and image-to-image generative AI models with Stable Diffusion-like capabilities

EMA Code
Exponential Moving Average it’s a technique used to make results better and more stable training. It works by keeping a copy of the model weights of the previous iteration and updating the current iteration weights by a factor of (1-beta).

class EMA:
    def __init__(self, beta):
        self.beta = beta
        self.step = 0
    def update_model_average(self, ma_model, current_model):
        for current_params, ma_params in zip(current_model.parameters(), ma_model.parameters()):
            old_weight, up_weight =,
   = self.update_average(old_weight, up_weight)
    def update_average(self, old, new):
        if old is None:
            return new
        return old * self.beta + (1 - self.beta) * new
    def step_ema(self, ema_model, model, step_start_ema=2000):
        if self.step < step_start_ema:
            self.reset_parameters(ema_model, model)
            self.step += 1
        self.update_model_average(ema_model, model)
        self.step += 1
    def reset_parameters(self, ema_model, model):

We have refactored the code to make it functional. The training step happens on the one_epoch function:

 def train_step(self):
        self.ema.step_ema(self.ema_model, self.model)
    def one_epoch(self, train=True, use_wandb=False):
        avg_loss = 0.
        if train: self.model.train()
        else: self.model.eval()
        pbar = progress_bar(self.train_dataloader, leave=False)
        for i, (images, labels) in enumerate(pbar):
            with torch.autocast("cuda") and (torch.inference_mode() if not train else torch.enable_grad()):
                images =
                labels =
                t = self.sample_timesteps(images.shape[0]).to(self.device)
                x_t, noise = self.noise_images(images, t)
                if np.random.random() < 0.1:
                    labels = None
                predicted_noise = self.model(x_t, t, labels)
                loss = self.mse(noise, predicted_noise)
                avg_loss += loss
            if train:
                if use_wandb: 
                    wandb.log({"train_mse": loss.item(),
                                "learning_rate": self.scheduler.get_last_lr()[0]})
            pbar.comment = f"MSE={loss.item():2.3f}"        
        return avg_loss.mean().item()

Here, you can see in the first part of our W&B instrumentation we log the training loss and the learning rate value. This way we can follow the scheduler we are using. To actually log the samples, we define a custom function to perform model inference:

def log_images(self):
    "Log images to wandb and save them to disk"
    labels = torch.arange(self.num_classes).long().to(self.device)
    sampled_images = self.sample(use_ema=False, n=len(labels), labels=labels)
    ema_sampled_images = self.sample(use_ema=True, n=len(labels), labels=labels)
    plot_images(sampled_images)  #to display on jupyter if available
    # log images to wandb
    wandb.log({"sampled_images":     [wandb.Image(img.permute(1,2,0).squeeze().cpu().numpy()) for img in sampled_images]})
    wandb.log({"ema_sampled_images": [wandb.Image(img.permute(1,2,0).squeeze().cpu().numpy()) for img in ema_sampled_images]})

And also a function to save the model checkpoints:

def save_model(self, run_name, epoch=-1):
    "Save model locally and to wandb", os.path.join("models", run_name, f"")), os.path.join("models", run_name, f"")), os.path.join("models", run_name, f""))
    at = wandb.Artifact("model", type="model", description="Model weights for DDPM conditional", metadata={"epoch": epoch})
    at.add_dir(os.path.join("models", run_name))

Everything fits into the fit function

def prepare(self, args):
    "Prepare the model for training"
    device = args.device
    self.train_dataloader, self.val_dataloader = get_data(args)
    self.optimizer = optim.AdamW(self.model.parameters(),, weight_decay=0.001)
    self.scheduler = optim.lr_scheduler.OneCycleLR(self.optimizer,, 
                                                steps_per_epoch=len(self.train_dataloader), epochs=args.epochs)
    self.mse = nn.MSELoss()
    self.ema = EMA(0.995)
    self.scaler = torch.cuda.amp.GradScaler()
def fit(self, args):
    for epoch in range(args.epochs):"Starting epoch {epoch}:")
        ## validation
        if args.do_validation:
        # log predicitons
        if epoch % args.log_every_epoch == 0:
    # save model
    self.save_model(run_name=args.run_name, use_wandb=args.use_wandb, epoch=epoch)

Step 4: Model evaluation

Model performance metrics: The step after model training will require you to evaluate it. In this step, the model’s predictions of the actual outcomes of the test set will be compared. Some performance metrics that can be used to evaluate the performance of a diffusion model include accuracy, precision, recall, and F1 score.

Interpretation of model results: Evaluating the performance of the model includes your ability to interpret the results of the model. By understanding relationships between individuals in the population and how they influence the diffusion process, you are able to achieve this. This step may also involve identifying the most influential individuals in the population and the factors that contribute to their influence.

Model refinement: Refining the model is crucial to improve its performance. The model’s parameters may need adjusting, additional data may need to be collected, or the selection of a different type of diffusion model might be required at this stage. The end goal of this process is to ensure that the model accurately represents the relationships between individuals in the population and provides useful insights into the diffusion process. The refinement process may involve repeating the model training and evaluation steps multiple times until the desired level of performance is achieved.


Step 5: Implementation

Deployment of the trained model: Deployment refers to integrating the model into a production environment so that it can be used to make predictions on new data. Some methods include assimilating the model on a cloud platform, as a web service, or even as part of a larger software application.

Integration with other systems: Integration with other models can allow the deployed model to become part of a larger solution. The model can be integrated with a database, an API, or a user interface. The goal of integration is to ensure that the model works in tandem with the rest of the system and is also able to provide accurate predictions in real time.

Ongoing maintenance and monitoring: Once the model has been deployed, it will need constant monitoring to function optimally and provide accurate predictions over time. Monitoring the model also includes adjusting the model parameters, retraining it with new data, or replacing it entirely if it is no longer effective.

Training diffusion models in machine learning: The future

  • Improved accuracy of predictions: Developing new methods to enhance the accuracy of predictions made by diffusion models, such as employing more advanced algorithms or involving additional new data sources.
  • Developing new models: Creating newer models that are designed to handle only certain types of data or problems, such as models for predicting the spread of infectious diseases. These models will also be more interpretable so that domain experts can better understand and validate their predictions.
  • Model deployment in new domains: Exploring the use of diffusion models in new areas, such as finance or healthcare, to further demonstrate their potential and flexibility.
  • Incorporating uncertainty: Placing uncertainty into the predictions made by diffusion models will make them look more trustworthy, robust and authentic.
  • Hybrid models: Diffusion models, along with other types of models, such as deep learning models or reinforcement learning models, can work together to bring about improved accuracy and versatility.


Machine learning is a constantly evolving field with diverse applications across various industries. The development of diffusion models has opened up new possibilities for generating high-quality videos and images, modeling physical systems, and making predictions based on data. To effectively train a diffusion model, it is crucial to carefully select the appropriate model and parameters, train it on relevant data, and evaluate its performance. By doing so, diffusion models can provide valuable insights and predictions in a wide range of applications. As the field of machine learning continues to progress, it will be exciting to see how diffusion models will continue to contribute to its advancements.

Unlock the power of AI with our custom Stable Diffusion development services. Our team of experts develops robust solutions leveraging technologies like deep learning, machine learning, computer vision and natural language.

Listen to the article
What is Chainlink VRF

Author’s Bio


Akash Takyar

Akash Takyar
CEO LeewayHertz
Akash Takyar is the founder and CEO at LeewayHertz. The experience of building over 100+ platforms for startups and enterprises allows Akash to rapidly architect and design solutions that are scalable and beautiful.
Akash's ability to build enterprise-grade technology solutions has attracted over 30 Fortune 500 companies, including Siemens, 3M, P&G and Hershey’s.
Akash is an early adopter of new technology, a passionate technology enthusiast, and an investor in AI and IoT startups.

Start a conversation by filling the form

Once you let us know your requirement, our technical expert will schedule a call and discuss your idea in detail post sign of an NDA.
All information will be kept confidential.


Follow Us