RECODE-H / annotations /annotation_4 /TabDiff /tabdiff /models /unified_ctime_diffusion.py
mcy98's picture
Upload folder using huggingface_hub
6077218 verified
Raw History Blame Contribute Delete
41 kB
import torch.nn.functional as F
import torch
import math
import numpy as np
from tabdiff.models.noise_schedule import *
from tqdm import tqdm
from itertools import chain
"""
“Our implementation of the continuous-time masked diffusion is inspired by https://arxiv.org/abs/2406.07524's implementation at [https://github.com/kuleshov-group/mdlm], with modifications to support data distributions that include categorical dimensions of different sizes.”
"""
# These parameters, inspired by the EDM paper (Karras et al., 2022), control the behavior of the stochastic sampler.
# S_churn: The amount of stochasticity to inject at each step.
# S_min, S_max: The range of noise levels (sigma) where stochasticity is active.
# S_noise: The magnitude of the noise added during the stochastic step.
S_churn= 1
S_min=0
S_max=float('inf')
S_noise=1
class UnifiedCtimeDiffusion(torch.nn.Module):
"""
This class implements the TABDIFF model, a unified continuous-time diffusion framework
for generating mixed-type tabular data, as described in the paper "TABDIFF: A MIXED-TYPE
DIFFUSION MODEL FOR TABULAR DATA GENERATION".
The model handles both numerical and categorical features within a single diffusion process.
- Numerical features are diffused using a Gaussian diffusion process (Section 2.2).
- Categorical features are diffused using a masked diffusion process (Section 2.2).
- The model supports learnable, feature-wise noise schedules to handle data heterogeneity (Section 2.3).
- Sampling can be performed using a standard ODE solver or an advanced stochastic sampler (Section 2.4).
- It also supports classifier-free guidance for conditional generation tasks like imputation (Section 2.5).
"""
def __init__(
self,
num_classes: np.array,
num_numerical_features: int,
denoise_fn,
y_only_model,
num_timesteps=1000,
scheduler='power_mean',
cat_scheduler='log_linear',
noise_dist='uniform',
edm_params={},
noise_dist_params={},
noise_schedule_params={},
sampler_params={},
device=torch.device('cpu'),
**kwargs
):
"""
Initializes the UnifiedCtimeDiffusion model.
Args:
num_classes (np.array): An array where each element is the number of categories for a categorical feature.
num_numerical_features (int): The number of numerical features in the dataset.
denoise_fn: The main denoising network model. Corresponds to the 'Denoising Network' in Figure 1.
y_only_model: A separate, smaller denoising network trained only on the target columns for
classifier-free guidance (CFG). This corresponds to the unconditional model over the
missing columns mentioned in Section 2.5 of the paper.
num_timesteps (int): The number of discretization steps to use during sampling.
scheduler (str): The noise schedule for numerical features. The paper proposes 'power_mean'
and 'power_mean_per_column' for adaptive learning.
cat_scheduler (str): The noise schedule for categorical features. The paper proposes 'log_linear'
and 'log_linear_per_column' for adaptive learning.
noise_dist (str): The distribution from which to sample noise levels during training.
edm_params (dict): Parameters related to the Elucidating Design space of diffusion Models (EDM)
framework by Karras et al. (2022), which influences the loss calculation and sampling.
noise_dist_params (dict): Parameters for the noise distribution.
noise_schedule_params (dict): Parameters for the noise schedule, like sigma_min and sigma_max.
sampler_params (dict): Parameters to control the sampling process, e.g., enabling the stochastic sampler.
device: The device (CPU or GPU) to run the model on.
"""
super(UnifiedCtimeDiffusion, self).__init__()
self.num_numerical_features = num_numerical_features
# A vector [K1, K2, ..., Km] where Ki is the number of categories for the i-th categorical feature.
self.num_classes = num_classes
self.num_classes_expanded = torch.from_numpy(
np.concatenate([num_classes[i].repeat(num_classes[i]) for i in range(len(num_classes))])
).to(device) if len(num_classes)>0 else torch.tensor([]).to(device).int()
# The index for the [MASK] token for each categorical feature. The paper notes an extra dimension
# is dedicated to the [MASK] state.
self.mask_index = torch.tensor(self.num_classes).long().to(device)
self.neg_infinity = -1000000.0
# The number of categories for each feature, including the mask token.
self.num_classes_w_mask = tuple(self.num_classes + 1)
# The following are helper attributes for slicing and managing the one-hot encoded categorical features.
# This is an implementation detail necessary for handling multiple categorical features with varying
# numbers of classes within a single tensor.
offsets = np.cumsum(self.num_classes)
offsets = np.append([0], offsets)
self.slices_for_classes = []
for i in range(1, len(offsets)):
self.slices_for_classes.append(np.arange(offsets[i - 1], offsets[i]))
self.offsets = torch.from_numpy(offsets).to(device)
offsets = np.cumsum(self.num_classes) + np.arange(1, len(self.num_classes)+1)
offsets = np.append([0], offsets)
self.slices_for_classes_with_mask = []
for i in range(1, len(offsets)):
self.slices_for_classes_with_mask.append(np.arange(offsets[i - 1], offsets[i]))
self._denoise_fn = denoise_fn
self.y_only_model = y_only_model
self.num_timesteps = num_timesteps
self.scheduler = scheduler
self.cat_scheduler = cat_scheduler
self.noise_dist = noise_dist
self.edm_params = edm_params
self.noise_dist_params = noise_dist_params
self.sampler_params = sampler_params
# The stochastic sampler and second-order correction are only applicable when numerical features exist,
# as they are based on continuous ODE solvers. This is an implementation-specific constraint.
if self.num_numerical_features == 0:
self.sampler_params['stochastic_sampler'] = False
self.sampler_params['second_order_correction'] = False
# These attributes are for configuring classifier-free guidance during imputation.
self.w_num = 0.0 # Guidance strength for numerical features
self.w_cat = 0.0 # Guidance strength for categorical features
self.num_mask_idx = [] # Indices of missing numerical features
self.cat_mask_idx = [] # Indices of missing categorical features
self.device = device
# Instantiate the noise schedules based on the configuration.
# This implements the "Adaptively Learnable Noise Schedules" from Section 2.3 of the paper.
# `power_mean_per_column` and `log_linear_per_column` correspond to the feature-wise learnable schedules.
if self.scheduler == 'power_mean':
self.num_schedule = PowerMeanNoise(**noise_schedule_params)
elif self.scheduler == 'power_mean_per_column':
self.num_schedule = PowerMeanNoise_PerColumn(num_numerical = num_numerical_features, **noise_schedule_params)
else:
raise NotImplementedError(f"The noise schedule--{self.scheduler}-- is not implemented for contiuous data at CTIME ")
if self.cat_scheduler == 'log_linear':
self.cat_schedule = LogLinearNoise(**noise_schedule_params)
elif self.cat_scheduler == 'log_linear_per_column':
self.cat_schedule = LogLinearNoise_PerColumn(num_categories = len(num_classes), **noise_schedule_params)
else:
raise NotImplementedError(f"The noise schedule--{self.cat_scheduler}-- is not implemented for discrete data at CTIME ")
def mixed_loss(self, x):
"""
Calculates the mixed-type diffusion loss for a batch of data.
This function corresponds to the joint objective function L_TABDIFF in Eq. (12) of the paper.
"""
b = x.shape[0]
device = x.device
x_num = x[:, :self.num_numerical_features]
x_cat = x[:, self.num_numerical_features:].long()
# 1. Sample a time step 't' uniformly, as described in Algorithm 1.
# From 't', derive the noise levels (sigma) for both numerical and categorical features using their schedules.
if self.noise_dist == "uniform_t":
t = torch.rand(b, device=device, dtype=x_num.dtype)
t = t[:, None]
sigma_num = self.num_schedule.total_noise(t)
sigma_cat = self.cat_schedule.total_noise(t)
dsigma_cat = self.cat_schedule.rate_noise(t) # Derivative needed for categorical loss weight.
else:
# An alternative sampling strategy, not described in the main paper, where noise level sigma is sampled
# directly and then mapped back to time 't'. This is a common practice in continuous-time diffusion models.
sigma_num = self.sample_ctime_noise(x)
t = self.num_schedule.inverse_to_t(sigma_num)
while torch.any((t < 0) + (t > 1)):
# restrict t to [0,1]
# this iterative approach is equivalent to sampling from a truncated version of the orignal noise distribution
invalid_idx = ((t < 0) + (t > 1)).nonzero().squeeze(-1)
sigma_num[invalid_idx] = self.sample_ctime_noise(x[:len(invalid_idx)])
t = self.num_schedule.inverse_to_t(sigma_num)
assert not torch.any((t < 0) + (t > 1))
sigma_cat = self.cat_schedule.total_noise(t)
dsigma_cat = self.cat_schedule.rate_noise(t)
# Convert sigma_cat to alpha (probability of not being masked) for the categorical forward process.
# alpha_t = exp(-sigma_cat(t)) as defined in Section 2.2.
alpha = torch.exp(-sigma_cat)
move_chance = -torch.expm1(-sigma_cat) # This is 1 - alpha_t, calculated for numerical stability.
# 2. Apply the forward diffusion process to corrupt the data (as in Figure 1 'Forward Diff').
# For numerical features, add Gaussian noise according to Eq. (3) .
x_num_t = x_num
if x_num.shape[1] > 0:
noise = torch.randn_like(x_num)
x_num_t = x_num + noise * sigma_num
# For categorical features, apply the masking process according to Eq. (6) .
x_cat_t = x_cat
# x_cat_t_soft is a one-hot representation of the noised data, used as input to the network.
x_cat_t_soft = x_cat
if x_cat.shape[1] > 0:
# When using learnable schedules, 'move_chance' is a vector, requiring a 'soft' Gumbel-Softmax
# implementation for correct gradient flow. This is an implementation detail not specified in the paper.
is_learnable = self.cat_scheduler == 'log_linear_per_column'
strategy = 'soft' if is_learnable else 'hard'
x_cat_t, x_cat_t_soft = self.q_xt(x_cat, move_chance, strategy=strategy)
# 3. Get the model's prediction of the original data (or noise) from the corrupted data.
model_out_num, model_out_cat = self._denoise_fn(
x_num_t, x_cat_t_soft,
t.squeeze(), sigma=sigma_num
)
d_loss = torch.zeros((1,)).float()
c_loss = torch.zeros((1,)).float()
# 4. Calculate the individual loss components.
# Numerical loss corresponds to L_num in Eq. (5) , with EDM-style weighting.
if x_num.shape[1] > 0:
c_loss = self._edm_loss(model_out_num, x_num, sigma_num)
# Categorical loss corresponds to L_cat in Eq. (9) .
if x_cat.shape[1] > 0:
# The parameterization transforms the model's raw output to log probabilities of the original classes.
logits = self._subs_parameterization(model_out_cat, x_cat_t)
d_loss = self._absorbed_closs(logits, x_cat, sigma_cat, dsigma_cat)
return d_loss.mean(), c_loss.mean()
@torch.no_grad()
def sample(self, num_samples):
"""
Generates new samples using the trained diffusion model, following the reverse process.
This function implements the sampling procedure, conceptually similar to Algorithm 2.
"""
b = num_samples
device = self.device
dtype = torch.float32
# Create the time discretization schedule from t=1.0 down to t=0.0.
t = torch.linspace(0,1,self.num_timesteps, dtype=dtype, device=device)
t = t[:, None]
# Pre-calculate the noise levels (sigma) for each time step in the schedule.
sigma_num_cur = self.num_schedule.total_noise(t)
sigma_cat_cur = self.cat_schedule.total_noise(t)
# sigma_next is the noise level of the *next* step in the reverse process (i.e., a smaller sigma).
sigma_num_next = torch.zeros_like(sigma_num_cur)
sigma_num_next[1:] = sigma_num_cur[0:-1]
sigma_cat_next = torch.zeros_like(sigma_cat_cur)
sigma_cat_next[1:] = sigma_cat_cur[0:-1]
# This block sets up the 'stochastic sampler' described in Section 2.4.
# It calculates a slightly noisier version of sigma (sigma_hat) for each step, which corresponds
# to perturbing the sample from x_t to x_{t+gamma} before the main denoising step (see Algorithm 2).
# The formula for gamma is a heuristic from Karras et al. (2022).
if self.sampler_params['stochastic_sampler']:
gamma = min(S_churn / self.num_timesteps, np.sqrt(2) - 1) * (S_min <= sigma_num_cur) * (sigma_num_cur <= S_max)
sigma_num_hat = sigma_num_cur + gamma * sigma_num_cur
t_hat = self.num_schedule.inverse_to_t(sigma_num_hat)
# Take the smallest t_hat induced by the per-column sigmas to ensure all features are within a valid time range.
t_hat = torch.min(t_hat, dim=-1, keepdim=True).values
zero_gamma = (gamma==0).any()
t_hat[zero_gamma] = t[zero_gamma]
out_of_bound = (t_hat > 1).squeeze()
sigma_num_hat[out_of_bound] = sigma_num_cur[out_of_bound]
t_hat[out_of_bound] = t[out_of_bound]
sigma_cat_hat = self.cat_schedule.total_noise(t_hat)
else:
t_hat = t
sigma_num_hat = sigma_num_cur
sigma_cat_hat = sigma_cat_cur
# Start the reverse process from pure noise at t=1.0.
# Numerical features start from a Gaussian distribution, as in Algorithm 2, line 1.
z_norm = torch.randn((b, self.num_numerical_features), device=device) * sigma_num_cur[-1]
# Categorical features start from the [MASK] state, as in Algorithm 2, line 1.
has_cat = len(self.num_classes) > 0
z_cat = torch.zeros((b, 0), device=device).float()
if has_cat:
z_cat = self._sample_masked_prior(
b,
len(self.num_classes),
)
# Iterate backwards through the time steps from T-1 down to 0.
pbar = tqdm(reversed(range(0, self.num_timesteps)), total=self.num_timesteps)
pbar.set_description(f"Sampling Progress")
for i in pbar:
z_norm, z_cat, q_xs = self.edm_update(
z_norm, z_cat, i,
t[i], t[i-1] if i > 0 else None, t_hat[i],
sigma_num_cur[i], sigma_num_next[i], sigma_num_hat[i],
sigma_cat_cur[i], sigma_cat_next[i], sigma_cat_hat[i],
)
# By the end of the process, all categorical features should be unmasked.
assert torch.all(z_cat < self.mask_index)
sample = torch.cat([z_norm, z_cat], dim=1).cpu()
return sample
def sample_all(self, num_samples, batch_size, keep_nan_samples=False):
"""
A wrapper function to generate a large number of samples in batches.
This is an implementation detail for practical large-scale sampling.
"""
b = batch_size
all_samples = []
num_generated = 0
while num_generated < num_samples:
print(f"Samples left to generate: {num_samples-num_generated}")
sample = self.sample(b)
mask_nan = torch.any(sample.isnan(), dim=1)
if keep_nan_samples:
# If sample instances that contain NaN are to be kept, force the row to all zeros.
sample = sample * (~mask_nan)[:, None]
else:
# Otherwise, discard instances with NaN values.
sample = sample[~mask_nan]
all_samples.append(sample)
num_generated += sample.shape[0]
x_gen = torch.cat(all_samples, dim=0)[:num_samples]
return x_gen
def q_xt(self, x, move_chance, strategy='hard'):
"""
Performs the forward diffusion process for categorical features (masking).
Corresponds to q(x_t|x_0) in Eq. (6).
Args:
x: The original categorical data (integer-encoded).
move_chance: The probability of transitioning to the [MASK] state (1 - alpha_t).
strategy: 'hard' for standard masking, 'soft' for a Gumbel-Softmax-based approach needed
for per-column learnable schedules to allow gradient flow. This is an implementation detail.
"""
if strategy == 'hard':
# Each token is flipped to [MASK] independently with probability `move_chance`.
move_indices = torch.rand(*x.shape, device=x.device) < move_chance
xt = torch.where(move_indices, self.mask_index, x)
# Convert to one-hot for the network input.
xt_soft = self.to_one_hot(xt).to(move_chance.dtype)
return xt, xt_soft
elif strategy == 'soft':
# This 'soft' strategy is necessary when move_chance is different for each column (learnable schedule).
# It uses Gumbel-Softmax to make the discrete choice of masking differentiable, which is
# crucial for backpropagating through the schedule's learnable parameters. This is a sophisticated
# implementation detail not explicitly mentioned in the paper.
bs = x.shape[0]
xt_soft = torch.zeros(bs, torch.sum(self.mask_index+1), device=x.device)
xt = torch.zeros_like(x)
for i in range(len(self.num_classes)):
slice_i = self.slices_for_classes_with_mask[i]
prob_i = torch.zeros(bs, 2, device=x.device)
prob_i[:,0] = 1-move_chance[:,i]
prob_i[:,-1] = move_chance[:,i]
log_prob_i = torch.log(prob_i)
soft_sample_i = F.gumbel_softmax(log_prob_i, tau=0.01, hard=True)
idx = torch.stack((x[:,i]+slice_i[0], torch.ones_like(x[:,i])*slice_i[-1]), dim=-1)
xt_soft[torch.arange(len(idx)).unsqueeze(1), idx] = soft_sample_i
xt[:, i] = torch.where(soft_sample_i[:,1] > soft_sample_i[:,0], self.mask_index[i], x[:,i])
return xt, xt_soft
def _subs_parameterization(self, unormalized_prob, xt):
"""
Processes the raw output of the denoising network for categorical features. It converts the output
into log-probabilities and enforces the logic of the masked diffusion process.
This is a key part of implementing the reverse transition p_theta(x_s|x_t) from Eq. (8) .
"""
# The model outputs unnormalized probabilities for each possible category. This function pads them
# to a uniform size for batch processing.
unormalized_prob = self.pad(unormalized_prob, self.neg_infinity)
# Set the probability of predicting the [MASK] token to zero (log prob to -inf).
unormalized_prob[:, range(unormalized_prob.shape[1]), self.mask_index] += self.neg_infinity
# Convert to log-probabilities (logits) via log-softmax.
logits = unormalized_prob - torch.logsumexp(unormalized_prob, dim=-1, keepdim=True)
# Enforce the rule from Eq. (8): if a token is not masked (x_t != m), it stays the same.
# This is done by setting the log-probabilities for unmasked tokens to -inf for all categories
# except the actual token's category, which is set to 0 (prob=1).
unmasked_indices = (xt != self.mask_index)
logits[unmasked_indices] = self.neg_infinity
logits[unmasked_indices, xt[unmasked_indices]] = 0
return logits
def pad(self, x, pad_value):
"""
Helper function for implementation. It converts a concatenated tensor of class probabilities
(with different numbers of classes per feature) into a single padded matrix. This allows for
efficient batch processing. This is a standard engineering solution for handling
heterogeneous categorical data and not a specific concept from the paper.
"""
splited = torch.split(x, self.num_classes_w_mask, dim=-1)
max_K = max(self.num_classes_w_mask)
padded_ = [
torch.cat((
t,
pad_value*torch.ones(*(t.shape[:-1]), max_K-t.shape[-1], dtype=t.dtype, device=t.device)
), dim=-1)
for t in splited]
out = torch.stack(padded_, dim=-2)
return out
def to_one_hot(self, x_cat):
"""Helper function to convert integer-encoded categorical data to one-hot format."""
x_cat_oh = torch.cat(
[F.one_hot(x_cat[:, i], num_classes=self.num_classes[i]+1,) for i in range(len(self.num_classes))],
dim=-1
)
return x_cat_oh
def _absorbed_closs(self, model_output, x0, sigma, dsigma):
"""
Calculates the categorical loss based on the continuous-time evidence lower bound (ELBO).
This directly implements the loss L_cat from Eq. (9) and (12).
"""
# Get the predicted log probability of the true original data x0.
log_p_theta = torch.gather(
model_output, -1, x0[:, :, None]
).squeeze(-1)
alpha = torch.exp(-sigma)
# This is the weighting term from the continuous-time ELBO: (alpha_t' / (1 - alpha_t)).
# It's calculated here based on sigma for numerical stability.
if self.cat_scheduler in ['log_linear', 'log_linear_per_column']:
# The paper defines alpha_t = exp(-sigma_cat(t)).
# So, alpha_t' = -dsigma * exp(-sigma) = -dsigma * alpha.
# And 1 - alpha_t = 1 - exp(-sigma) = -expm1(-sigma).
# The weight is alpha_t'/(1-alpha_t), which is different from the implementation's -dsigma/expm1(sigma).
# Let's re-derive: alpha_t' / (1-alpha_t) = (-dsigma * alpha) / (1-alpha).
# The paper later uses dsigma in the loss without the alpha term in the numerator. Let's re-check the paper.
# Looking at Eq. (143), the integral has (alpha_t' / (1-alpha_t)).
# Looking at the code's `move_chance`, it's -expm1(-sigma), which is 1 - exp(-sigma) = 1 - alpha.
# And dsigma is sigma'. So the weight is (alpha'/(1-alpha)) = (-sigma' * exp(-sigma)) / (1-exp(-sigma)).
# The code calculates `-dsigma / torch.expm1(sigma)`.
# `expm1(sigma)` is `exp(sigma) - 1`. So the weight is `-dsigma / (exp(sigma)-1)`.
# This is `-dsigma * exp(-sigma) / (1 - exp(-sigma))`, which is `alpha' / (1-alpha)`.
# So the implementation IS correct, it just uses a numerically stable rearrangement.
# Let's re-verify the formula in the paper again: Eq (143) is `(alpha_t' / (1 - alpha_t))`. My math checks out.
# The code seems to use `dsigma / (exp(sigma) - 1)` which is `sigma' / (exp(sigma) - 1)`.
# This is not equal to `alpha' / (1 - alpha)`.
# `expm1(sigma)` is `exp(sigma) - 1`.
# `alpha' = -sigma' * exp(-sigma)`. `1-alpha = 1 - exp(-sigma)`.
# `alpha'/(1-alpha) = -sigma' * exp(-sigma) / (1-exp(-sigma)) = -sigma' / (exp(sigma) - 1)`.
# The code has `-dsigma / torch.expm1(sigma)`. This is `dsigma` not `dsigma * alpha`. Let's re-check `dsigma_cat` calculation. It is `self.cat_schedule.rate_noise(t)`, which is `sigma'`.
# My derivation of the paper's formula is `-sigma' / (exp(sigma)-1)`.
# The code is `-dsigma / expm1(sigma)`.
# This seems correct.
# Wait, `alpha_t = exp(-sigma)`. alpha_t' = -sigma' * exp(-sigma). So the weight is -sigma' * exp(-sigma) / (1-exp(-sigma)).
# Code: -dsigma / expm1(sigma) = -sigma' / (exp(sigma)-1) = -sigma' * exp(-sigma) / (1-exp(-sigma)).
# Yes, the code is a correct and numerically stable implementation of the formula in the paper.
elbo_weight = - dsigma / torch.expm1(sigma)
else:
# Fallback for simpler schedules.
elbo_weight = -1/(1-alpha)
loss = elbo_weight * log_p_theta
return loss
def _sample_masked_prior(self, *batch_dims):
"""Helper to create a batch of all-masked categorical data for the start of sampling."""
return self.mask_index[None,:] * torch.ones(*batch_dims, dtype=torch.int64, device=self.mask_index.device)
def _mdlm_update(self, log_p_x0, x, alpha_t, alpha_s):
"""
Performs one reverse step for categorical features, sampling x_s from x_t.
This implements the sampling from the posterior distribution p_theta(x_s|x_t) described by Eq. (8),
using the closed-form transition probabilities from Eq. (7) .
Args:
log_p_x0: The model's prediction of the log-probabilities of the original data (logits).
x: The current noisy sample x_t.
alpha_t: The non-mask probability at the current time t.
alpha_s: The non-mask probability at the next time s.
"""
move_chance_t = 1 - alpha_t
move_chance_s = 1 - alpha_s
move_chance_t = move_chance_t.unsqueeze(-1)
move_chance_s = move_chance_s.unsqueeze(-1)
assert move_chance_t.ndim == log_p_x0.ndim
# This calculates the categorical distribution for the next step, q(x_s|x_t, x_0_pred).
# It's based on Eq. (7), where the probability of transitioning to the predicted x0 is proportional to (alpha_s - alpha_t),
# and the probability of remaining masked is proportional to (1 - alpha_s).
# The term (1 - alpha_t) is a normalizer and can be omitted for Gumbel-max sampling.
q_xs = log_p_x0.exp() * (move_chance_t - move_chance_s)
q_xs[:, range(q_xs.shape[1]), self.mask_index] = move_chance_s[:, :, 0]
# Ensure that dummy classes (from padding) have zero probability.
dummy_mask = torch.tensor([[(1 if i <= mask_idx else 0) for i in range(max(self.mask_index+1))] for mask_idx in self.mask_index], device=q_xs.device)
dummy_mask = torch.ones_like(q_xs) * dummy_mask
q_xs *= dummy_mask
# Sample from the calculated distribution.
_x = self._sample_categorical(q_xs)
# The core logic of the reverse process: if a token in x is already unmasked, it stays the same.
# If it is masked, it is updated to the newly sampled value _x.
# This matches Eq. (8), where p(x_s|x_t) is a delta function if x_t is not masked.
copy_flag = (x != self.mask_index).to(x.dtype)
z_cat = copy_flag * x + (1 - copy_flag) * _x
return z_cat, q_xs
def _sample_categorical(self, categorical_probs):
"""Samples from a categorical distribution using the Gumbel-Max trick."""
gumbel_norm = (1e-10 - (torch.rand_like(categorical_probs) + 1e-10).log())
return (categorical_probs / gumbel_norm).argmax(dim=-1)
def sample_ctime_noise(self, batch):
"""Samples noise level sigma from a specified distribution, e.g., Log-Normal."""
if self.noise_dist == 'log_norm':
rnd_normal = torch.randn(batch.shape[0], device=batch.device)
sigma = (rnd_normal * self.noise_dist_params['P_std'] + self.noise_dist_params['P_mean']).exp()
else:
raise NotImplementedError(f"The noise distribution--{self.noise_dist}-- is not implemented for CTIME ")
return sigma
def _edm_loss(self, D_yn, y, sigma):
"""
Calculates the numerical loss based on the EDM framework.
This corresponds to L_num in Eq. (5) , but uses a specific weighting scheme from Karras et al. (2022)
to improve training stability and performance, which is an advanced implementation detail.
"""
weight = (sigma ** 2 + self.edm_params['sigma_data'] ** 2) / (sigma * self.edm_params['sigma_data']) ** 2
target = y
loss = weight * ((D_yn - target) ** 2)
return loss
def edm_update(
self, x_num_cur, x_cat_cur, i,
t_cur, t_next, t_hat,
sigma_num_cur, sigma_num_next, sigma_num_hat,
sigma_cat_cur, sigma_cat_next, sigma_cat_hat,
):
"""
Performs a single update step in the reverse diffusion process, from time t to t-1.
This function is the core of the sampler and implements the steps in Algorithm 2.
"""
cfg = self.y_only_model is not None # Check if running in classifier-free guidance mode.
b = x_num_cur.shape[0]
has_cat = len(self.num_classes) > 0
# 1. Stochastic Sampler Forward Perturbation (Algorithm 2, steps 3-7).
# This is the "kick" of the stochastic sampler, adding a small amount of noise.
# x_hat is the state at the slightly noiser time t_hat.
x_num_hat = x_num_cur + (sigma_num_hat ** 2 - sigma_num_cur ** 2).sqrt() * S_noise * torch.randn_like(x_num_cur)
move_chance = -torch.expm1(sigma_cat_cur - sigma_cat_hat)
x_cat_hat, _ = self.q_xt(x_cat_cur, move_chance) if has_cat else (x_cat_cur, x_cat_cur)
# 2. Get Denoised Prediction from the network, using the perturbed state x_hat.
x_cat_hat_oh = self.to_one_hot(x_cat_hat).to(x_num_hat.dtype) if has_cat else x_cat_hat
denoised, raw_logits = self._denoise_fn(
x_num_hat.float(), x_cat_hat_oh,
t_hat.squeeze().repeat(b), sigma=sigma_num_hat.unsqueeze(0).repeat(b,1)
)
# 3. Apply Classifier-Free Guidance (CFG) if enabled (Section 2.5).
# This modifies the prediction to steer it towards the conditional distribution.
is_learnable = self.scheduler=="power_mean_per_column"
if cfg:
# The logic to get sigma_cond for the y_only_model is an implementation detail to ensure
# the unconditional model is queried with a consistent noise level.
if not is_learnable:
sigma_cond = sigma_num_hat
else:
sigma_cond = sigma_num_hat[:, self.num_mask_idx]
# Get predictions from the unconditional (y_only) model.
y_num_hat = x_num_hat.float()[:, self.num_mask_idx]
idx = list(chain(*[self.slices_for_classes_with_mask[i] for i in self.cat_mask_idx]))
y_cat_hat = x_cat_hat_oh[:,idx]
y_only_denoised, y_only_raw_logits = self.y_only_model(
y_num_hat, y_cat_hat,
t_hat.squeeze().repeat(b), sigma=sigma_cond.unsqueeze(0).repeat(b,1)
)
# Interpolate the conditional and unconditional predictions as per Eq. (15) & (16).
denoised[:, self.num_mask_idx] *= 1 + self.w_num
denoised[:, self.num_mask_idx] -= self.w_num*y_only_denoised
mask_logit_idx = [self.slices_for_classes_with_mask[i] for i in self.cat_mask_idx]
mask_logit_idx = np.concatenate(mask_logit_idx) if len(mask_logit_idx)>0 else np.array([])
raw_logits[:, mask_logit_idx] *= 1 + self.w_cat
raw_logits[:, mask_logit_idx] -= self.w_cat*y_only_raw_logits
# 4. Denoising Step (Main ODE step).
# Numerical update using Euler step (Algorithm 2, step 8).
d_cur = (x_num_hat - denoised) / sigma_num_hat
x_num_next = x_num_hat + (sigma_num_next - sigma_num_hat) * d_cur
# Categorical update (unmasking) (Algorithm 2, step 10).
x_cat_next = x_cat_cur
q_xs = torch.zeros_like(x_cat_cur).float()
if has_cat:
logits = self._subs_parameterization(raw_logits, x_cat_hat)
alpha_t = torch.exp(-sigma_cat_hat).unsqueeze(0).repeat(b,1)
alpha_s = torch.exp(-sigma_cat_next).unsqueeze(0).repeat(b,1)
x_cat_next, q_xs = self._mdlm_update(logits, x_cat_hat, alpha_t, alpha_s)
# 5. Apply Second-Order Correction.
# Discrepancy: This is an advanced sampling technique from Karras et al. (2022) to improve sample quality,
# which is mentioned in Appendix F.2 but not in the main method description of the paper.
# It uses a second network evaluation to get a more accurate estimate of the trajectory.
if self.sampler_params['second_order_correction']:
if i > 0:
x_cat_hat_oh = self.to_one_hot(x_cat_next).to(x_num_next.dtype) if has_cat else x_cat_hat
denoised, raw_logits = self._denoise_fn(
x_num_next.float(), x_cat_hat_oh,
t_next.squeeze().repeat(b), sigma=sigma_num_next.unsqueeze(0).repeat(b,1)
)
if cfg:
if not is_learnable:
sigma_cond = sigma_num_next
else:
sigma_cond = sigma_num_next[:, self.num_mask_idx]
y_num_next = x_num_next.float()[:, self.num_mask_idx]
idx = list(chain(*[self.slices_for_classes_with_mask[i] for i in self.cat_mask_idx]))
y_cat_hat = x_cat_hat_oh[:, idx]
y_only_denoised, y_only_raw_logits = self.y_only_model(
y_num_next, y_cat_hat,
t_next.squeeze().repeat(b), sigma=sigma_cond.unsqueeze(0).repeat(b,1)
)
denoised[:, self.num_mask_idx] *= 1 + self.w_num
denoised[:, self.num_mask_idx] -= self.w_num*y_only_denoised
d_prime = (x_num_next - denoised) / sigma_num_next
x_num_next = x_num_hat + (sigma_num_next - sigma_num_hat) * (0.5 * d_cur + 0.5 * d_prime)
return x_num_next, x_cat_next, q_xs
def sample_impute(self, x_num, x_cat, num_mask_idx, cat_mask_idx, resample_rounds, impute_condition, w_num, w_cat):
"""
Performs conditional sampling for the missing value imputation task (Section 4.3).
This method uses a resampling strategy similar to 'RePaint' to fill in missing values while
keeping known values fixed.
Discrepancy/Implementation Detail: The paper mentions using TABDIFF for imputation but does not
detail this specific resampling algorithm. This is a common and effective technique for
conditional generation with diffusion models, but its implementation here is a detail not
provided in the paper's main method section.
"""
self.w_num = w_num
self.w_cat = w_cat
self.num_mask_idx = num_mask_idx
self.cat_mask_idx = cat_mask_idx
b = x_num.size(0)
device = self.device
dtype = torch.float32
# Create masks to distinguish known vs. unknown (missing) columns.
num_mask = torch.tensor([i in num_mask_idx for i in range(self.num_numerical_features)], device=x_num.device, dtype=x_num.dtype)
cat_mask = torch.tensor([i in cat_mask_idx for i in range(len(self.num_classes))], device=x_cat.device, dtype=x_cat.dtype)
# Standard setup for time steps and noise schedules.
t = torch.linspace(0,1,self.num_timesteps, dtype=dtype, device=device)[:, None]
sigma_num_cur = self.num_schedule.total_noise(t)
sigma_cat_cur = self.cat_schedule.total_noise(t)
sigma_num_next = torch.zeros_like(sigma_num_cur); sigma_num_next[1:] = sigma_num_cur[0:-1]
sigma_cat_next = torch.zeros_like(sigma_cat_cur); sigma_cat_next[1:] = sigma_cat_cur[0:-1]
if self.sampler_params['stochastic_sampler']:
gamma = min(S_churn / self.num_timesteps, np.sqrt(2) - 1) * (S_min <= sigma_num_cur) * (sigma_num_cur <= S_max)
sigma_num_hat = sigma_num_cur + gamma * sigma_num_cur
t_hat = self.num_schedule.inverse_to_t(sigma_num_hat)
t_hat = torch.min(t_hat, dim=-1, keepdim=True).values
zero_gamma = (gamma==0).any()
t_hat[zero_gamma] = t[zero_gamma]
out_of_bound = (t_hat > 1).squeeze()
sigma_num_hat[out_of_bound] = sigma_num_cur[out_of_bound]
t_hat[out_of_bound] = t[out_of_bound]
sigma_cat_hat = self.cat_schedule.total_noise(t_hat)
else:
t_hat = t
sigma_num_hat = sigma_num_cur
sigma_cat_hat = sigma_cat_cur
# Initialize the state. 'impute_condition' is an implementation detail determining if we start
# from the original data (x_0) or a fully noised version (x_t), which affects how known values are handled.
if impute_condition == "x_t":
z_norm = x_num + torch.randn((b, self.num_numerical_features), device=device) * sigma_num_cur[-1]
elif impute_condition == "x_0":
z_norm = x_num
has_cat = len(self.num_classes) > 0
z_cat = torch.zeros((b, 0), device=device).float()
if has_cat:
if impute_condition == "x_t":
z_cat = self._sample_masked_prior(b, len(self.num_classes))
elif impute_condition == "x_0":
z_cat = x_cat
pbar = tqdm(reversed(range(0, self.num_timesteps)), total=self.num_timesteps)
pbar.set_description(f"Sampling Progress")
for i in pbar:
# The resampling loop. At each time step, we can perform multiple updates.
for u in range (resample_rounds):
# 1. Get the known part: Noise the original known data to the current time step `t`.
if impute_condition == "x_t":
z_norm_known = x_num + torch.randn((b, self.num_numerical_features), device=device) * sigma_num_next[i]
move_chance = 1 - torch.exp(-sigma_cat_next[i]) if i < (self.num_timesteps-1) else torch.ones_like(sigma_cat_next[i])
z_cat_known, _ = self.q_xt(x_cat, move_chance)
elif impute_condition == "x_0":
z_norm_known = x_num
z_cat_known = x_cat
# 2. Get the unknown part: Perform one reverse step on the full data.
z_norm_unknown, z_cat_unknown, q_xs = self.edm_update(
z_norm, z_cat, i,
t[i], t[i-1] if i > 0 else None, t_hat[i],
sigma_num_cur[i], sigma_num_next[i], sigma_num_hat[i],
sigma_cat_cur[i], sigma_cat_next[i], sigma_cat_hat[i],
)
# 3. Combine known and unknown parts: Replace the known part of the denoised sample with the
# correctly noised known values. This is the core of the 'RePaint' logic.
z_norm = (1 - num_mask) * z_norm_known + num_mask * z_norm_unknown
z_cat = (1 - cat_mask) * z_cat_known + cat_mask * z_cat_unknown
# 4. Resample: For the next resampling iteration, add noise back to go from t-1 to t,
# so the next update step can refine the result.
if u < resample_rounds-1:
z_norm = z_norm + (sigma_num_cur[i] ** 2 - sigma_num_next[i] ** 2).sqrt() * S_noise * torch.randn_like(z_norm)
move_chance = -torch.expm1(sigma_cat_next[i] - sigma_cat_cur[i])
z_cat, _ = self.q_xt(z_cat, move_chance)
sample = torch.cat([z_norm, z_cat], dim=1).cpu()
return sample