Download annotations/annotation_4/TabDiff/tabdiff/models/unified_ctime_diffusion.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 41 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_4/TabDiff/tabdiff/models/unified_ctime_diffusion.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_4/TabDiff/tabdiff/models/unified_ctime_diffusion.py
-
curl -L -o unified_ctime_diffusion.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_4/TabDiff/tabdiff/models/unified_ctime_diffusion.py
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() | |
| 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 |