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

Generative Artificial Intelligence (AI), a rapidly growing technology used to generate unique data and content with minimal human intervention is poised to bring about transformative outcomes in the field of digital content creation. Generative AI algorithms can create new music, images, code, simulations and even entire websites in a matter of seconds. AI-supported virtual assistants like Siri and Alexa use Generative AI algorithms to respond to queries and provide insightful information. The use of Generative AI leads to faster completion of content generation tasks, which offers benefits at both individual and organizational levels. As technology advances, Generative AI will likely become capable of handling even more complex tasks like putting together scientific papers or creating visual design mock-ups. Prominent Generative AI models like Generative Adversarial Networks (GANs), Variational AutoEncoders (VAEs), Generative Pretrained Transformer 3 (GPT-3), and other similar generative AI models have been attracting a lot of attention in recent times. Diffusion models are generative deep learning models that learn the underlying data distribution of inputs through a controlled and steady diffusion process to produce high-quality and diverse outputs. The models offer solutions for several applications, such as text generation, audio processing, and image categorization.

This article discusses what a diffusion model is, its purpose, the different types of diffusion models, some key characteristics of diffusion processes, some factors affecting the diffusion process, and then deep dives into the process of training one. The article covers five detailed steps in training a diffusion model: data preparation, model selection, model training, model evaluation and implementation. Finally, we will look at what can be anticipated in future work on training diffusion models in machine learning.

What is a diffusion model?

Introduced in 2015, diffusion models, also known as diffusion probabilistic models are a class of latent variable models. These are Markov chains trained using variational inference. The sole intention of a diffusion model is to imbibe the latent structure of a dataset by modeling a way where data points diffuse through the latent space. By learning to reverse the diffusion process, a neural network is able to denoise images blurred with Gaussian noise. Three examples of generic diffusion modeling frameworks used in computer vision are denoising diffusion probabilistic models, noise-conditioned score networks, and stochastic differential equations. Diffusion models can be applied to tasks such as image denoising, inpainting, super-resolution, and image generation. An example of a diffusion model is OpenAI’s DALL-E 2, which would start with a random noise image and then, after having been trained to reverse the diffusion process on natural images, the model could generate new natural images. DALL-E 2 uses diffusion models for the model’s prior, which produces an image embedding a text caption and the decoder that produces the final image.

What is the purpose of a diffusion model?

A diffusion model attempts to understand and simulate the dissemination of ideas, information, and innovations within a group over time. Through social networks, diffusion models can be used to study the movement of information to predict the acceptance of newer technologies and analyze the spread of diseases in epidemiology, among many other applications. Diffusion models can be used to make predictions about the future spread of information. The overarching purpose of a diffusion model is to provide an exhaustive understanding of the process of information circulation and its impact on people, which can, in turn, be useful in various fields and applications.

What are the different types of diffusion models?

In the field of machine learning, some of the most commonly used diffusion models to study the spread of information or ideas within a populace include:

Social network embedding models

These models capture the underlying structure and relationships between individuals and learn a low-dimensional representation of individuals on the same social network. This representation can be used to predict the dissemination of information through the network. Some models that have been developed for social network embedding include but are not limited to DeepWalk, GraRep, Node2Vec and Struc2Vec.

Deep generative models

Using deep neural networks, these models generate fabricated data that can then be used to study the diffusion of information. A generative model could be trained on real diffusion data and then employed to generate its own data with similar properties, which can eventually be used to study the workings of other diffusion models. Some examples of deep generative models include Variational Autoencoders (VAE), Generative Adversarial Networks (GAN), Autoregressive models (such as PixelCNN or PixelRNN) and Flow-based Generative Models (such as RealNVP or Glow).

Reinforcement learning models

Using reinforcement learning algorithms to study the spread of information through a network, these models have individual networks or agents, and the circulation of information is represented as a series of actions taken by these individual networks. Some examples of reinforcement learning models include Q-Learning, SARSA (State-Action-Reward-State-Action), Deep Q-Network (DQN), and Policy Gradients (PG).

Graph convolutional networks

These models use graph convolutional networks to learn the structure of a social network and the relationships between individuals. The learned representations can then be used to predict the spread of information or ideas through the network. Some graph convolutional network models include Graph Attention Network (GAT), Chebyshev Graph Convolutional Network (ChebNet) and Spectral Graph Convolutional Network (SGC), among others.

Each of these machine learning models has its own advantages and limitations, and the choice of model will depend on the specific application and the data available.

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

Launch your project with LeewayHertz

What are some of the key characteristics of diffusion processes?

Network structure

The dynamics between individuals play a significant role in the diffusion of data. Machine learning models can learn the structure of a network and make predictions about the dissemination of information.

Temporal dynamics

Diffusion processes evolve over time. ML models can capture the temporal dynamics of diffusion, including the rate of spread and the time it takes for information to reach a group of individuals.


Each individual has their own characteristics, such as different levels of influence or different thresholds for adoption, which can then be used to make predictions about the spread of information.

Influence mechanisms

The spread of information can be influenced through word-of-mouth, marketing campaigns, and incentives. Machine learning models can capture these influence mechanisms, which can then be used to make predictions about the spread of information.
Feedback loops: The spread of information can have feedback, with early adopters influencing the decisions of later adopters. Machine learning models can capture feedback loops in the diffusion process, which can then be used to make predictions about the spread of information.

These are some of the key characteristics of diffusion processes in machine learning, which provide a framework for modeling and understanding the spread of information within a population.

What are some other factors affecting diffusion?

  • Social influence: The spread of information can be influenced by the decisions and behaviors of other members in the network. This can result in the magnification or dampening of information diffusion.
  • Information quality: The quality of the information being diffused can strongly impact the diffusion rate. Ill-designed or incorrect information may not diffuse as effectively as well-designed, correct information.
  • Time and context: The diffusion of information can be influenced by the timing of the information and the specific context in which it is being diffused. For example, the diffusion rate may be faster in a crisis situation or slower in a context where the information is irrelevant.

These key factors provide a framework for understanding the complex processes that govern the spread of information within a population. Machine learning models can make more accurate predictions about the diffusion of information and help design more effective strategies for promoting or slowing down the spread of information by considering these factors.

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 Model

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)

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

Launch your project with LeewayHertz

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.


ML is an extremely dynamic arena, having revolutionized many fields and industries. It has the potential to change the way we live and work, and it will be interesting to see how it continues to develop in the coming times. Talking about training a diffusion model, it involves several steps, including choosing a diffusion model that is the right fit for the data, selecting the relevant parameters and hyperparameters, and training the model using the selected data. It is also important to evaluate the model’s performance and make necessary adjustments to optimize its accuracy. Finally, the trained model should be deployed and integrated into a production environment for use. With the right intent, diffusion models can provide key insights and predictions in a wide range of applications.

Unlock the power of AI with our custom stable diffusion services. Our team of experts develop 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.