Download annotations/annotation_38/PreferDiff/diffusion.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 12.3 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_38/PreferDiff/diffusion.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_38/PreferDiff/diffusion.py
-
curl -L -o diffusion.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_38/PreferDiff/diffusion.py
12.3 kB
| import torch | |
| import numpy as np | |
| import torch.nn.functional as F | |
| from modules import extract, betas_for_alpha_bar, linear_beta_schedule, exp_beta_schedule, cosine_beta_schedule | |
| class BaseDiffusion(): | |
| def __init__(self, config): | |
| self.config = config | |
| self.timesteps = config['timesteps'] | |
| self.device = config['device'] | |
| self.w = config['w'] | |
| self.betas = self.get_beta_schedule(config['beta_sche'], config['timesteps'], config['beta_start'], | |
| config['beta_end']) | |
| self.alphas = 1. - self.betas | |
| self.alphas_cumprod = torch.cumprod(self.alphas, axis=0) | |
| self.alphas_cumprod_prev = F.pad(self.alphas_cumprod[:-1], (1, 0), value=1.0) | |
| self.sqrt_recip_alphas = torch.sqrt(1.0 / self.alphas) | |
| self.sqrt_alphas_cumprod = torch.sqrt(self.alphas_cumprod) | |
| self.sqrt_one_minus_alphas_cumprod = torch.sqrt(1. - self.alphas_cumprod) | |
| self.sqrt_recip_alphas_cumprod = torch.sqrt(1. / self.alphas_cumprod) | |
| self.sqrt_recipm1_alphas_cumprod = torch.sqrt(1. / self.alphas_cumprod - 1) | |
| self.posterior_mean_coef1 = self.betas * torch.sqrt(self.alphas_cumprod_prev) / (1. - self.alphas_cumprod) | |
| self.posterior_mean_coef2 = (1. - self.alphas_cumprod_prev) * torch.sqrt(self.alphas) / ( | |
| 1. - self.alphas_cumprod) | |
| self.posterior_variance = self.betas * (1. - self.alphas_cumprod_prev) / (1. - self.alphas_cumprod) | |
| self.init_ddim_variables() | |
| def get_beta_schedule(self, beta_sche, timesteps, beta_start, beta_end): | |
| if beta_sche == 'linear': | |
| return linear_beta_schedule(timesteps=timesteps, beta_start=beta_start, beta_end=beta_end) | |
| elif beta_sche == 'exp': | |
| return exp_beta_schedule(timesteps=timesteps) | |
| elif beta_sche == 'cosine': | |
| return cosine_beta_schedule(timesteps=timesteps) | |
| elif beta_sche == 'sqrt': | |
| return torch.tensor(betas_for_alpha_bar(timesteps, lambda t: 1 - np.sqrt(t + 0.0001))).float() | |
| else: | |
| raise ValueError("Invalid beta schedule") | |
| def init_ddim_variables(self): | |
| indices = list(range(0, self.timesteps + 1, self.config['ddim_step'])) | |
| self.sub_timesteps = len(indices) | |
| indices_now = [indices[i] - 1 for i in range(len(indices))] | |
| indices_now[0] = 0 | |
| self.alphas_cumprod_ddim = self.alphas_cumprod[indices_now] | |
| self.alphas_cumprod_ddim_prev = F.pad(self.alphas_cumprod_ddim[:-1], (1, 0), value=1.0) | |
| self.sqrt_recipm1_alphas_cumprod_ddim = torch.sqrt(1. / self.alphas_cumprod_ddim - 1) | |
| self.posterior_ddim_coef1 = torch.sqrt(self.alphas_cumprod_ddim_prev) - torch.sqrt( | |
| 1. - self.alphas_cumprod_ddim_prev) / self.sqrt_recipm1_alphas_cumprod_ddim | |
| self.posterior_ddim_coef2 = torch.sqrt(1. - self.alphas_cumprod_ddim_prev) / torch.sqrt( | |
| 1. - self.alphas_cumprod_ddim) | |
| def q_sample(self, x_start, t, noise=None): | |
| if noise is None: | |
| noise = torch.randn_like(x_start) | |
| sqrt_alphas_cumprod_t = extract(self.sqrt_alphas_cumprod, t, x_start.shape) | |
| sqrt_one_minus_alphas_cumprod_t = extract(self.sqrt_one_minus_alphas_cumprod, t, x_start.shape) | |
| return sqrt_alphas_cumprod_t * x_start + sqrt_one_minus_alphas_cumprod_t * noise | |
| def i_sample(self, model_forward, model_forward_uncon, x, y, t, t_index): | |
| x_start = (1 + self.w) * model_forward(x, y, t) - self.w * model_forward_uncon(x, t) | |
| x_t = x | |
| model_mean = ( | |
| self.posterior_ddim_coef1[t_index] * x_start + | |
| self.posterior_ddim_coef2[t_index] * x_t | |
| ) | |
| return model_mean | |
| def sample_from_noise(self, model_forward, model_forward_uncon, h): | |
| x = torch.randn_like(h).to(h.device) | |
| for n in reversed(range(self.sub_timesteps)): | |
| step = torch.full((h.shape[0],), n * self.config['ddim_step'], device=h.device, dtype=torch.long) | |
| x = self.i_sample(model_forward, model_forward_uncon, x, h, step, n) | |
| return x | |
| def p_losses(self, denoise_model, x_start, h, t, noise=None, loss_type="l2"): | |
| if noise is None: | |
| noise = torch.randn_like(x_start) | |
| x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise) | |
| def cosine_loss(pred_matrix, gt_matrix): | |
| pred_norm = F.normalize(pred_matrix, p=2, dim=1) | |
| gt_norm = F.normalize(gt_matrix, p=2, dim=1) | |
| dot_product = torch.sum(pred_norm * gt_norm, dim=1) | |
| loss = torch.mean((dot_product - 1) ** 2) | |
| return loss | |
| def sce_loss(x, y, alpha=0.2): | |
| x = F.normalize(x, p=2, dim=-1) | |
| y = F.normalize(y, p=2, dim=-1) | |
| loss = (1 - (x * y).sum(dim=-1)).pow_(alpha) | |
| loss = loss.mean() | |
| return loss | |
| predicted_x = denoise_model.denoise(x_noisy, h, t) | |
| if loss_type == 'l1': | |
| loss = F.l1_loss(x_start, predicted_x) | |
| elif loss_type == 'l2': | |
| loss = F.mse_loss(x_start, predicted_x) | |
| elif loss_type == "huber": | |
| loss = F.smooth_l1_loss(x_start, predicted_x) | |
| elif loss_type == "cosine": | |
| loss = cosine_loss(x_start, predicted_x) | |
| else: | |
| raise NotImplementedError() | |
| return loss, {'main': loss} | |
| def get_x(self, denoise_model, x_start, h, t, noise=None, loss_type="l2"): | |
| if noise is None: | |
| noise = torch.randn_like(x_start) | |
| x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise) | |
| predicted_x = denoise_model.denoise(x_noisy, h, t) | |
| return predicted_x | |
| def predict_noise_from_start(self, x_t, t, x0): | |
| return ( | |
| (extract(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - x0) / \ | |
| extract(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) | |
| ) | |
| def p_sample(self, model_forward, model_forward_uncon, x, h, t, t_index): | |
| x_start = (1 + self.w) * model_forward(x, h, t) - self.w * model_forward_uncon(x, t) | |
| x_t = x | |
| model_mean = ( | |
| extract(self.posterior_mean_coef1, t, x_t.shape) * x_start + | |
| extract(self.posterior_mean_coef2, t, x_t.shape) * x_t | |
| ) | |
| if t_index == 0: | |
| return model_mean | |
| else: | |
| posterior_variance_t = extract(self.posterior_variance, t, x.shape) | |
| noise = torch.randn_like(x) | |
| return model_mean + torch.sqrt(posterior_variance_t) * noise | |
| def sample(self, model, h, mode='ddim'): | |
| if mode=='ddpm': | |
| x = torch.randn_like(h) | |
| for n in reversed(range(0, self.timesteps)): | |
| step = torch.full((h.shape[0],), n, device=self.device, dtype=torch.long) | |
| x = self.p_sample(model.denoise, model.denoise_uncon, x, h, step, n) | |
| else: | |
| x = self.sample_from_noise(model.denoise, model.denoise_uncon, h) | |
| return x | |
| def ddim_sample(self, model_forward, model_forward_uncon, h, ddim_timesteps=100, ddim_discr_method='uniform'): | |
| if ddim_discr_method == 'uniform': | |
| c = self.timesteps // ddim_timesteps | |
| ddim_timestep_seq = np.arange(0, self.timesteps, c) | |
| elif ddim_discr_method == 'quad': | |
| ddim_timestep_seq = (np.linspace(0, np.sqrt(self.timesteps * .8), ddim_timesteps) ** 2).astype(int) | |
| else: | |
| raise NotImplementedError(f'There is no ddim discretization method called "{ddim_discr_method}"') | |
| x_t = torch.randn_like(h) | |
| ddim_timestep_seq += 1 | |
| ddim_timestep_prev_seq = np.append(np.array([0]), ddim_timestep_seq[:-1]) | |
| for i in reversed(range(0, ddim_timesteps)): | |
| t = torch.full((h.shape[0],), ddim_timestep_seq[i], device=self.device, dtype=torch.long) | |
| prev_t = torch.full((h.shape[0],), ddim_timestep_prev_seq[i], device=self.device, dtype=torch.long) | |
| predicted_x_0 = (1 + self.w) * model_forward(x_t, h, t) - self.w * model_forward_uncon(x_t, t) | |
| alpha_t = extract(self.alphas, t, x_t.shape) | |
| alpha_prev_t = extract(self.alphas, prev_t, x_t.shape) | |
| x_t = torch.sqrt(alpha_prev_t) * predicted_x_0 + torch.sqrt((1 - alpha_t) / alpha_prev_t) * ( | |
| x_t - torch.sqrt(alpha_prev_t) * predicted_x_0) | |
| return x_t | |
| class PreferenceDiffusion(BaseDiffusion): | |
| def __init__(self, config): | |
| super().__init__(config=config) | |
| self.gamma = config['gamma'] | |
| self.lamda = config['lamda'] | |
| self.mode = config['mode'] | |
| self.ab = config.get('ab', None) | |
| self.losses = [] | |
| self.loss_poss = [] | |
| self.loss_negs = [] | |
| def p_losses(self, denoise_model, x_start_pos, x_start_neg, h, t, noise=None, loss_type="l2"): | |
| if noise is None: | |
| noise = torch.randn_like(x_start_pos) | |
| if loss_type != 'sdpo': | |
| x_start_neg = torch.mean(x_start_neg, dim=1) | |
| def cosine_loss(pred_matrix, gt_matrix): | |
| pred_norm = F.normalize(pred_matrix, p=2, dim=1) | |
| gt_norm = F.normalize(gt_matrix, p=2, dim=1) | |
| # 计算点积 | |
| dot_product = torch.sum(pred_norm * gt_norm, dim=1) | |
| # 计算与1之间的均方误差损失 | |
| loss = torch.mean((dot_product - 1) ** 2) | |
| # x = F.normalize(pred_matrix, p=2, dim=-1) | |
| # y = F.normalize(gt_matrix, p=2, dim=-1) | |
| # loss = (1 - (x * y).sum(dim=-1)).pow_(self.config['tau']) | |
| # | |
| # loss = loss.mean() | |
| return loss | |
| loss_func = { | |
| 'l1': F.l1_loss, | |
| 'l2': F.mse_loss, | |
| 'huber': F.smooth_l1_loss, | |
| 'sdpo': F.mse_loss, | |
| 'cosine': cosine_loss, | |
| }.get(loss_type) | |
| if loss_func is None: | |
| raise NotImplementedError() | |
| x_noisy_pos = self.q_sample(x_start=x_start_pos, t=t, noise=noise) | |
| x_noisy_neg = self.q_sample(x_start=x_start_neg, t=t) | |
| predicted_x_pos = denoise_model.denoise(x_noisy_pos, h, t) | |
| predicted_x_neg = denoise_model.denoise(x_noisy_neg, h, t) | |
| neg_indices = torch.randint(0, h.shape[0], (h.shape[0],)) | |
| neg_h = h[neg_indices] | |
| # 负样本去噪 | |
| predicted_x_neg_h = denoise_model.denoise(x_noisy_pos, neg_h, t) | |
| loss_pos = loss_func(x_start_pos, predicted_x_pos) | |
| if loss_type != 'sdpo': | |
| loss_neg = loss_func(x_start_neg, predicted_x_neg) | |
| loss_neg_h = loss_func(x_start_pos, predicted_x_neg_h) | |
| else: | |
| loss_neg = F.mse_loss(x_start_neg, predicted_x_neg, reduction='none').sum(dim=2) | |
| B, N = loss_neg.shape | |
| loss_pos_expand = loss_pos.expand(B, N) | |
| loss_diff = torch.log(loss_neg - loss_pos_expand) | |
| loss = -F.logsigmoid( | |
| -torch.log(torch.mean(torch.sum(torch.exp(self.gamma * loss_diff), dim=1)) + 1e-8) + 1e-8) + loss_pos | |
| return loss, {'main': loss.detach().cpu()} | |
| model_diff = loss_pos - loss_neg | |
| if self.mode == 'neg': | |
| # loss = -1 * F.logsigmoid(-self.gamma * model_diff + 1e-8) + loss_pos | |
| loss = -(1 - self.lamda) * F.logsigmoid(-self.gamma * model_diff + 1e-8) + loss_pos * self.lamda | |
| elif self.mode == 'negh': | |
| h_loss = - F.logsigmoid(-0.01 * (loss_pos - loss_neg_h) + 1e-8) | |
| loss = loss_pos + h_loss + -F.logsigmoid(-self.gamma * model_diff + 1e-8) | |
| elif self.mode == 'dpo': | |
| loss = -F.logsigmoid(0 + 1e-8) + loss_pos | |
| elif self.mode == 'neg_sample': | |
| loss = -F.logsigmoid(-self.gamma * model_diff + 1e-8) | |
| else: | |
| raise ValueError('Unsupported mode') | |
| if self.ab == 'to': | |
| loss = loss_func(x_start_pos, predicted_x_pos) | |
| self.losses.append(loss.detach().cpu()) | |
| self.loss_poss.append(loss_pos.detach().cpu()) | |
| self.loss_negs.append(loss_neg.detach().cpu()) | |
| loss_dict = {'main': loss.detach().cpu(), 'pos': loss_pos.detach().cpu(), 'neg': loss_neg.detach().cpu()} | |
| return loss, loss_dict | |