mcy98's picture
Upload folder using huggingface_hub
6077218 verified
Raw History Blame Contribute Delete
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
@torch.no_grad()
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
@torch.no_grad()
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)
)
@torch.no_grad()
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
@torch.no_grad()
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
@torch.no_grad()
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