![hero copy.jpg](hero%20copy.jpg)--DIVIDER--# TL;DR Variational Auto-Encoders (VAEs) are versatile deep learning models with applications in data compression, noise reduction, synthetic data generation, anomaly detection, and missing data imputation. This publication demonstrates these capabilities using the MNIST dataset, providing practical insights for AI/ML practitioners. -----DIVIDER--# Introduction Variational Auto-Encoders (VAEs) are powerful generative models that exemplify unsupervised deep learning. They use a probabilistic approach to encode data into a distribution of latent variables, enabling both data compression and the generation of new, similar data instances. VAEs have become crucial in modern machine learning due to their ability to learn complex data distributions and generate new samples without requiring explicit labels. This versatility makes them valuable for tasks like image generation, enhancement, anomaly detection, and noise reduction across various domains including healthcare, autonomous driving, and multimedia generation. This publication demonstrates five key applications of VAEs: data compression, data generation, noise reduction, anomaly detection, and missing data imputation. By exploring these diverse use cases, we aim to showcase VAEs' versatility in solving various machine learning problems, offering practical insights for AI/ML practitioners. To illustrate these capabilities, we use the MNIST dataset of handwritten digits. This well-known dataset, consisting of 28x28 pixel grayscale images, provides a manageable yet challenging benchmark for exploring VAEs' performance in different data processing tasks. Through our examples with MNIST, we demonstrate how VAEs can effectively handle a range of challenges, from basic image compression to more complex tasks like anomaly detection and data imputation. Check the **Models** section for the github code repository for this publication.--DIVIDER--:::info{title="Note"} Although the original MNIST images are in black and white, we have utilized color palettes in our visualizations to make the demonstrations more visually engaging. :::--DIVIDER--# Understanding VAEs

Basic Concept and Architecture

VAEs are a class of generative models designed to encode data into a compressed latent space and then decode it to reconstruct the original input. The architecture of a VAE consists of two main components: the encoder and the decoder. --DIVIDER-- ![VAE_architecture.png](VAE_architecture.png)--DIVIDER--The diagram above illustrates the key components of a VAE: 1. Encoder: Compresses the input data into a latent space representation. 2. Latent Space (Z): Represents the compressed data as a probability distribution, typically Gaussian. 3. Decoder: Reconstructs the original input from a sample drawn from the latent space distribution. --DIVIDER--The encoder takes an input, such as an image, call it $X$, and compresses it into a set of parameters defining a probability distribution in the latent space—typically the mean and variance of a Gaussian distribution. This probabilistic approach is what sets VAEs apart; instead of encoding an input as a single point, it is represented as a distribution over potential values. The decoder then uses a sample from this distribution to reconstruct the original input (shows as $$\hat{X}$$). This sampling process would normally make the process non-differentiable. To overcome this challenge, VAEs use the so-called "reparameterization trick," which allows the model to back-propagate gradients through random operations by decomposing the sampling process into deterministic and stochastic components. This makes the VAE end-to-end differentiable which enables training using backpropagation.--DIVIDER--

Comparison with Traditional Auto-Encoders

While VAEs share some similarities with traditional auto-encoders, they have distinct features that set them apart. Understanding these differences is crucial for grasping the unique capabilities of VAEs. The following table highlights key aspects where VAEs differ from their traditional counterparts: --DIVIDER--| Aspect | Traditional Auto-Encoders | Variational Auto-Encoders (VAEs) | | --------------------- | ---------------------------------------- | ------------------------------------------------ | | Latent Space | • Deterministic encoding | • Probabilistic encoding | | | • Fixed point for each input | • Distribution (mean, variance) | | Objective Function | • Reconstruction loss | • Reconstruction loss + KL divergence | | | • Preserves input information | • Balances reconstruction and prior distribution | | Generative Capability | • Limited | • Inherently generative | | | • Primarily for dimensionality reduction | • Can generate new, unseen data | | Applications | • Feature extraction | • All traditional AE applications, plus: | | | • Data compression | • Synthetic generation | | | • Noise reduction | | | | • Missing Data Imputation | | | | • Anomaly Detection | | | Sampling | • Not applicable | • Can sample different points for same input | | Primary Function | • Data representation | • Data generation and representation |--DIVIDER--# VAE Example in PyTorch To better understand the practical implementation of a Variational Autoencoder, let's examine a concrete example using PyTorch, a popular deep learning framework. This implementation is designed to work with the MNIST dataset, encoding 28x28 pixel images into a latent space and then reconstructing them. The full code is available here: [Jupyter Notebook](https://github.com/readytensor/rt_img_compression_autoencoder/blob/main/src/vae.ipynb) The following code defines a VAE class that includes both the encoder and decoder networks. It also implements the reparameterization trick, which is crucial for allowing backpropagation through the sampling process. Additionally, we'll look at the loss function, which combines reconstruction loss with the Kullback-Leibler divergence to ensure the latent space has good properties for generation.--DIVIDER-- ```python class VAE(nn.Module): def __init__(self, latent_dim): super(VAE, self).__init__() # Encoder self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=2, padding=1) # Input is 1x28x28, output is 32x14x14 self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1) # Output is 64x7x7 self.fc1 = nn.Linear(64 * 7 * 7, 400) self.fc21 = nn.Linear(400, latent_dim) # mu self.fc22 = nn.Linear(400, latent_dim) # logvar # Decoder self.fc3 = nn.Linear(latent_dim, 400) self.fc4 = nn.Linear(400, 64 * 7 * 7) self.conv2_t = nn.ConvTranspose2d(64, 32, kernel_size=3, stride=2, padding=1, output_padding=1) # Output is 32x14x14 self.conv1_t = nn.ConvTranspose2d(32, 1, kernel_size=3, stride=2, padding=1, output_padding=1) # Output is 1x28x28 def encode(self, x): x = F.relu(self.conv1(x)) x = F.relu(self.conv2(x)) x = x.view(-1, 64 * 7 * 7) x = F.relu(self.fc1(x)) return self.fc21(x), self.fc22(x) def reparameterize(self, mu, logvar): std = torch.exp(0.5 * logvar) eps = torch.randn_like(std) return mu + eps * std def decode(self, z): z = F.relu(self.fc3(z)) z = F.relu(self.fc4(z)) z = z.view(-1, 64, 7, 7) z = F.relu(self.conv2_t(z)) z = torch.sigmoid(self.conv1_t(z)) return z def forward(self, x): mu, logvar = self.encode(x) z = self.reparameterize(mu, logvar) return self.decode(z), mu, logvar # Loss function def loss_function(recon_x, x, mu, logvar): # Calculate the Binary Cross Entropy loss between the reconstructed image and the original image BCE = F.binary_cross_entropy(recon_x, x, reduction='sum') # KL divergence measures how one probability distribution diverges from a second, expected probability distribution. # For VAEs, it measures how much information is lost when using the approximations of the distributions. KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp()) return BCE + KLD ``` --DIVIDER--Let's dissect each part of the code to understand how a VAE is built and operates using PyTorch, a popular deep learning library. First, we have the constructor: ```python def __init__(self, latent_dim): super(VAE, self).__init__() # Encoder self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=2, padding=1) # Input is 1x28x28, output is 32x14x14 self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1) # Output is 64x7x7 self.fc1 = nn.Linear(64 * 7 * 7, 400) self.fc21 = nn.Linear(400, latent_dim) # mu self.fc22 = nn.Linear(400, latent_dim) # logvar # Decoder self.fc3 = nn.Linear(latent_dim, 400) self.fc4 = nn.Linear(400, 64 * 7 * 7) self.conv2_t = nn.ConvTranspose2d(64, 32, kernel_size=3, stride=2, padding=1, output_padding=1) # Output is 32x14x14 self.conv1_t = nn.ConvTranspose2d(32, 1, kernel_size=3, stride=2, padding=1, output_padding=1) ``` The `__init__` method initializes the VAE. It takes latent_dim as an argument, specifying the size of the latent space, a key feature of the VAE that determines the dimensionality of the encoded representation. It contains the definition of the encoder and decoder parts.

Encoder Network

```python self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=2, padding=1) self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1) self.fc1 = nn.Linear(64 * 7 * 7, 400) self.fc21 = nn.Linear(400, latent_dim) # Mean (mu) self.fc22 = nn.Linear(400, latent_dim) # Log variance (logvar) ``` The Encoder consists of convolutional layers followed by fully connected layers. The convolutional layers help in capturing spatial hierarchies in the image data, reducing its dimensionality before it is mapped to the latent space parameters by the fully connected layers.

Decoder Network

```python self.fc3 = nn.Linear(latent_dim, 400) self.fc4 = nn.Linear(400, 64 * 7 * 7) self.conv2_t = nn.ConvTranspose2d(64, 32, kernel_size=3, stride=2, padding=1, output_padding=1) self.conv1_t = nn.ConvTranspose2d(32, 1, kernel_size=3, stride=2, padding=1, output_padding=1) ``` The Decoder utilizes transposed convolutional layers to perform the inverse operation of the encoder, upscaling the encoded latent representations back to the original image dimensions.

Loss function

```python def loss_function(recon_x, x, mu, logvar): BCE = F.binary_cross_entropy(recon_x, x, reduction='sum') KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp()) return BCE + KLD ``` The loss function combines binary cross-entropy (BCE) for reconstruction loss and the KL divergence (KLD) for regularizing the latent space distribution.

Additional Methods

```python def encode(self, x): x = F.relu(self.conv1(x)) x = F.relu(self.conv2(x)) x = x.view(-1, 64 * 7 * 7) x = F.relu(self.fc1(x)) return self.fc21(x), self.fc22(x) def reparameterize(self, mu, logvar): std = torch.exp(0.5 * logvar) eps = torch.randn_like(std) return mu + eps * std def decode(self, z): z = F.relu(self.fc3(z)) z = F.relu(self.fc4(z)) z = z.view(-1, 64, 7, 7) z = F.relu(self.conv2_t(z)) z = torch.sigmoid(self.conv1_t(z)) return z def forward(self, x): mu, logvar = self.encode(x) z = self.reparameterize(mu, logvar) return self.decode(z), mu, logvar ``` - Encode Function: Transforms the input image into two sets of parameters in the latent space, representing the means and log variances.
- Reparameterize Function: Uses the reparameterization trick to allow for gradient backpropagation through stochastic processes.
- Decode Function: Reconstructs the image from the latent space representation. --DIVIDER--:::info{title="Info"}

Note on Model Architecture

It's important to note that the architecture of Variational Auto-Encoders (VAEs) is highly adaptable and does not need to be confined to any specific type of layer or structure. VAEs can be designed using a variety of architectural components to suit specific tasks and data types. While convolutional layers are ideal for image data, fully connected (linear) layers may be better suited for tabular data. For sequential or time series data, incorporating LSTM (Long Short-Term Memory) layers can be highly effective. This flexibility allows VAEs to be tailored to a wide range of applications, optimizing performance across different types of data. :::--DIVIDER--:::info{title="Info"}

What is Reparameterization?

In the context of a VAE, the encoder network generates two parameters: mean (mu) and log-variance (logvar) of a Gaussian distribution. Instead of directly sampling from this distribution (which would inhibit gradient flow because sampling is a stochastic process), the reparameterization trick is used to decompose the sampling process into a deterministic part and a stochastic part.

Breakdown of the reparameterize Function

```python def reparameterize(self, mu, logvar): std = torch.exp(0.5 * logvar) # Convert log-variance to standard deviation eps = torch.randn_like(std) # Generate random noise with a standard normal distribution return mu + eps * std # Scale and shift the noise to create the sample ``` 1. Convert Log-Variance to Standard Deviation: - `std = torch.exp(0.5 * logvar)` The log variance (`logvar`) is transformed into the standard deviation (`std`). This transformation is necessary because the variance must be non-negative and the logarithm of variance can range from negative infinity to positive infinity, making it easier to optimize. The 0.5 factor is due to the properties of logarithms (since variance = exp(logvar) and std = sqrt(variance)). 2. Generate Random Noise: - `eps = torch.randn_like(std)` Random noise `eps` is generated from a standard normal distribution (mean = 0, std = 1) with the same shape as the standard deviation. This randomness introduces the stochastic element needed for the generative process. 3. Scale and Shift the Noise: - `return mu + eps * std` The noise is scaled by the standard deviation and shifted by the mean (`mu`). This step effectively samples from the Gaussian distribution defined by `mu` and `std`, but in a way that allows the gradients to flow back through the parameters `mu` and `logvar` during training. ::: --DIVIDER--# Applying VAEs: From Theory to Practice Now that we've explored the theoretical underpinnings of VAEs and examined a concrete implementation in PyTorch, let's dive into the practical applications of this powerful model. We'll start by focusing on one of the most fundamental capabilities of VAEs: data compression. In the following sections, we'll demonstrate how VAEs can be utilized for efficient data compression, using the MNIST dataset as our example. This application showcases the VAE's ability to capture the essence of complex data in a compact latent representation, a feature that has significant implications for data storage, transmission, and processing. --DIVIDER--:::info{title="Note on Applicability"} While our examples use MNIST for simplicity, the principles of VAE applications extend to various real-world datasets. These techniques can be adapted for diverse scenarios, from image processing to tabular data to time series analysis, offering powerful solutions for data compression, generation, denoising, anomaly detection, and imputation across different domains. :::--DIVIDER--## Data Compression and Dimensionality Reduction Modern data-driven applications often require efficient methods for data compression and dimensionality reduction to manage storage, processing, and transmission costs. Variational Autoencoders (VAEs) offer a powerful solution to this challenge, particularly for complex, high-dimensional data like images.

How VAEs Compress MNIST Images

Variational Auto-Encoders offer a novel approach to data compression through their probabilistic latent space. When applying VAEs to the MNIST dataset, the process involves:

1. Encoding: Each 28x28 pixel image of the MNIST dataset, representing handwritten digits, is input into the encoder part of the VAE. The encoder network compresses this image into a much smaller set of latent variables, capturing the essential features of the image in terms of mean and variance. Latent Space Representation: The critical information of each image is stored in a lower-dimensional latent space, where the size of this space is significantly smaller than the original image size, effectively compressing the image data.

2. Decoding: The decoder part of the VAE then takes these latent variables and reconstructs the image, aiming to match the original as closely as possible. The training process involves tuning the encoder and decoder to minimize the loss, ensuring that the essential features are preserved.

Visualizing Compressed vs. Original Digits

To demonstrate the effectiveness of VAEs in compressing MNIST images, we can visualize the original and the reconstructed images side by side: ![vae_reconstruction.jpg](vae_reconstruction.jpg) The results show how VAEs can effectively compress the 28x28 pixel images of handwritten digits into a lower-dimensional latent space of size 10 that is 1.2% of the original size. Despite this significant reduction in dimensionality, the reconstructed images closely resemble the originals, demonstrating the VAE's powerful ability to capture essential features while compressing the data.--DIVIDER--## Data Generation

The Need for Synthetic Data in AI/ML

Synthetic data generation plays a crucial role in AI/ML, especially when real data is scarce, sensitive, or expensive to collect. It's valuable for augmenting training datasets, improving model robustness, and providing controlled scenarios for testing and validation.

Generating New MNIST-like Digits with VAEs

VAEs stand out in their ability to generate new data that mimics the original training data. Here’s how VAEs can be used to generate new, MNIST-like digits:

1. **Training**: A VAE is first trained on the MNIST dataset, learning the underlying distribution of the data represented in a latent space.
2. **Sampling**: After training, new points are sampled from the latent space distribution. Because this space has been regularized during training (encouraged to approximate a Gaussian distribution), the samples are likely to be meaningful.
3. **Decoding**: These sampled latent points are then passed through the decoder, which reconstructs new digits that reflect the characteristics of the training data but are novel creations.

Exploring the Latent Space: Morphing Between Digits

One of the fascinating capabilities of VAEs is exploring and visualizing the continuity and interpolation capabilities within the latent space:

1. Continuous Interpolation: By choosing two points in the latent space corresponding to different digits, one can interpolate between these points. The decoder generates outputs that gradually transition from one digit to another, illustrating how features morph seamlessly from one to the other.

2. Visualizing Morphing: This can be visualized by creating a sequence of images where each image represents a step from one latent point to another. This not only demonstrates the smoothness of the latent space but also the VAE’s ability to handle and mix digit features creatively.

3. Insight into Latent Variables: Such explorations provide insights into what features are captured by different dimensions of the latent space (e.g., digit thickness, style, orientation). We trained a VAE on MNIST with a 2D latent space for easy visualization and manipulation. This allows us to observe how changes in latent variables affect generated images. The figure below shows generated images for latent dimension values from -3 to 3 on both axes: ![vae_grid_plot.jpg](vae_grid_plot.jpg) This exploration is not only a powerful demonstration of the model's internal representations but also serves as a tool for understanding and debugging the model’s behavior. --DIVIDER--## Noise Reduction Noise in data is a common issue in various fields, from medical imaging to autonomous vehicles. It can significantly degrade the performance of machine learning models, making effective denoising techniques crucial.

Demonstrating VAE-based Denoising on MNIST

We trained multiple VAEs to remove noise from MNIST images, testing different noise percentages. We created noisy images by randomly replacing a sample of pixels with values from a uniform distribution between 0 and 1. The following images show the denoising performance of VAEs at different levels of noise contamination: ![noisy_vs_denoised_0.05.jpg](noisy_vs_denoised_0.05.jpg) ![noisy_vs_denoised_0.1.jpg](noisy_vs_denoised_0.1.jpg) ![noisy_vs_denoised_0.25.jpg](noisy_vs_denoised_0.25.jpg) ![noisy_vs_denoised_0.5.jpg](noisy_vs_denoised_0.5.jpg) Results seen in the charts above demonstrate the VAE's capability in reconstructing clean images from noisy inputs, highlighting its potential in restoring and enhancing image data usability in practical scenarios. --DIVIDER--## Anomaly Detection Anomaly detection is crucial in various industries, identifying patterns that deviate from expected behavior. These anomalies can indicate critical issues such as fraudulent transactions or mechanical faults.

Using VAEs to Spot Anomalies in MNIST

VAEs can effectively detect anomalies by modeling the distribution of normal data: 1. The VAE is trained on MNIST digits. 2. Anomalies are identified by higher reconstruction loss on test set. 3. A threshold is set to flag digits with excessive loss as anomalies. The histogram below shows reconstruction errors on the test set: ![reconstruction_errors_histogram.jpg](reconstruction_errors_histogram.jpg) The following images show the top 10 digits with the highest loss, representing potential anomalies: ![highest_reconstruction_errors.jpg](highest_reconstruction_errors.jpg) We can confirm that the 10 samples are badly written digits and should be considered anomalies. To further test the VAE's anomaly detection capabilities, we tested the VAE model on images of letters—data that the model was not trained on. This experiment serves two purposes: 1. Validating the model's ability to identify clear out-of-distribution samples. 2. Exploring the nuances of how the model interprets shapes similar to digits. The following chart shows the original images of letters and their reconstructions. ![letter_reconstruction.jpg](letter_reconstruction.jpg) We also marked the reconstruction errors of the samples on the histogram of reconstruction errors from the test set. ![reconstruction_errors_with_letters.jpg](reconstruction_errors_with_letters.jpg) These visualizations reveal several interesting insights: 1. Most letters, except 'Z', show poor reconstructions and high reconstruction errors, clearly marking them as anomalies. 2. The letter 'Z' is reconstructed relatively well, likely due to its similarity to the digit '2'. Its reconstruction error falls within the normal range of the test set. 3. The letter 'M' shows the most distorted reconstruction, corresponding to the highest reconstruction error. This aligns with 'M' being the most dissimilar to any MNIST digit. 4. Interestingly, 'H' is reconstructed to somewhat resemble the digit '8', the closest MNIST digit in shape. While still an anomaly, it has the lowest error among the non-'Z' letters. This experiment highlights: - The VAE's effectiveness in identifying clear anomalies (most letters). - The model's tendency to interpret unfamiliar shapes in terms of the digits it knows. - The importance of shape similarities in the model's interpretation, as demonstrated by the 'Z' and 'H' cases. These observations underscore the VAE's capability in anomaly detection while also revealing its limitations when faced with out-of-distribution data that shares similarities with in-distribution samples.--DIVIDER--## Missing Data Imputation Incomplete data is a common challenge in machine learning, leading to biased estimates and less reliable models. This issue is prevalent in various domains, including healthcare and finance.

Reconstructing Partial MNIST Digits with VAEs

VAEs offer a robust approach to missing data imputation: 1. Training: A VAE learns the distribution of complete MNIST digits. 2. Simulating Missing Data: During training, parts of input digits are randomly masked. The VAE is tasked with reconstructing the full, original digit from this partial input. 3. Inference: When presented with new partial digits, the VAE leverages its learned distributions to infer and reconstruct missing sections, effectively filling in the gaps. This process enables the VAE to generalize from partial information, making it adept at handling various missing data scenarios. The image below demonstrates the VAE's capability in missing data imputation: ![missing_vs_reconstructed.jpg](missing_vs_reconstructed.jpg) These examples illustrate how effectively the VAE infers and reconstructs missing parts of the digits, showcasing its potential for data imputation tasks. --DIVIDER--# VAEs vs. GANs While this publication has focused on Variational Autoencoders (VAEs), it's important to consider how they compare to other popular generative models, particularly Generative Adversarial Networks (GANs). Both VAEs and GANs are powerful techniques for data generation in machine learning, but they approach the task in fundamentally different ways and have distinct strengths and weaknesses. GANs, introduced by Ian Goodfellow et al. in 2014, have gained significant attention for their ability to generate highly realistic images. They work by setting up a competition between two neural networks: a generator that creates fake data, and a discriminator that tries to distinguish fake data from real data. This adversarial process often results in very high-quality outputs, particularly in image generation tasks. Understanding the differences between VAEs and GANs can help practitioners choose the most appropriate model for their specific use case. The following table provides a detailed comparison of these two approaches: The following table provides a detailed comparison of these two approaches: | Aspect | Variational Autoencoders (VAEs) | Generative Adversarial Networks (GANs) | |--------|--------------------------------|----------------------------------------| | Output Quality | Slightly blurrier, but consistent | Sharper, more realistic images | | Training Process | Easier and usually faster to train, well-defined objective function | Can be challenging and time-consuming, potential mode collapse | | Latent Space | Structured and interpretable | Less structured, harder to control | | Versatility | Excel in both generation and inference tasks | Primarily focused on generation tasks | | Stability | More stable training, consistent results | Can suffer from training instability | | Primary Use Cases | Data compression, denoising, anomaly detection, controlled generation | High-fidelity image generation, data augmentation | | Reconstruction Ability | Built-in reconstruction capabilities | No inherent reconstruction ability | | Inference | Capable of inference on new data | Typically requires additional techniques for inference |

When to Choose VAEs over GANs

- Applications requiring both generation and reconstruction capabilities - Tasks needing interpretable and controllable latent representations - Scenarios demanding training stability and result consistency - Projects involving data compression, denoising, or anomaly detection - When balancing generation quality with ease of implementation and versatility - When faster training times are preferred--DIVIDER--# Conclusion This article has demonstrated the versatility of Variational Auto-Encoders (VAEs) across various machine learning applications, including data compression, generation, noise reduction, anomaly detection, and missing data imputation. VAEs' unique ability to model complex distributions and generate new data instances makes them powerful tools for tasks where traditional methods may fall short. We encourage researchers, developers, and enthusiasts to explore VAEs further. Whether refining architectures, applying them to new data types, or integrating them with other techniques, the potential for innovation is vast. We hope this exploration inspires you to incorporate VAEs into your work, contributing to technological advancement and opening new avenues for discovery. -----DIVIDER--# References 1. Kingma, D. P., & Welling, M. (2013). Auto-Encoding Variational Bayes. arXiv preprint arXiv:1312.6114. [https://arxiv.org/abs/1312.6114](https://arxiv.org/abs/1312.6114) 2. Goodfellow, I., Pouget-Abadie, J., Mirza, M., Xu, B., Warde-Farley, D., Ozair, S., Courville, A., & Bengio, Y. (2014). Generative Adversarial Nets. In Advances in Neural Information Processing Systems (pp. 2672-2680). [https://papers.nips.cc/paper/2014/file/5ca3e9b122f61f8f06494c97b1afccf3-Paper.pdf](https://papers.nips.cc/paper/2014/file/5ca3e9b122f61f8f06494c97b1afccf3-Paper.pdf)