from .base_pipeline import BasePipeline import torch def FlowMatchSFT_MSE_Loss(pipe: BasePipeline, **inputs): # print("using FlowMatchSFT_CLIP_Loss") # key="text_instruction_embeds" # print("text_instruction_embeds",inputs[key].shape) if key in inputs and isinstance(inputs[key], torch.Tensor) else None max_timestep_boundary = int(inputs.get("max_timestep_boundary", 1) * len(pipe.scheduler.timesteps)) min_timestep_boundary = int(inputs.get("min_timestep_boundary", 0) * len(pipe.scheduler.timesteps)) timestep_id = torch.randint(min_timestep_boundary, max_timestep_boundary, (1,)) timestep = pipe.scheduler.timesteps[timestep_id].to(dtype=pipe.torch_dtype, device=pipe.device) noise = torch.randn_like(inputs["input_latents"]) inputs["latents"] = pipe.scheduler.add_noise(inputs["input_latents"], noise, timestep) training_target = pipe.scheduler.training_target(inputs["input_latents"], noise, timestep) models = {name: getattr(pipe, name) for name in pipe.in_iteration_models} noise_pred,emb_after_connector = pipe.model_fn(**models, **inputs, timestep=timestep,output_connector_embeds=True) diff_loss = torch.nn.functional.mse_loss(noise_pred.float(), training_target.float()) diff_loss = diff_loss * pipe.scheduler.training_weight(timestep) # ----- calculate clip loss ----- text_instruction_embeds=inputs["text_instruction_embeds"] text_global = text_instruction_embeds.mean(dim=1) # [B, D] image_global = emb_after_connector.mean(dim=1) # [B, D] mse_loss = torch.nn.functional.mse_loss(image_global, text_global) #joint training diff_weight=1.0 loss=mse_loss+diff_weight*diff_loss print("mse_loss",mse_loss,"diff_loss",diff_loss) return loss # def FlowMatchSFTLoss(pipe: BasePipeline, **inputs): # # key="text_instruction_embeds" # # print("text_instruction_embeds",inputs[key].shape) if key in inputs and isinstance(inputs[key], torch.Tensor) else None # max_timestep_boundary = int(inputs.get("max_timestep_boundary", 1) * len(pipe.scheduler.timesteps)) # min_timestep_boundary = int(inputs.get("min_timestep_boundary", 0) * len(pipe.scheduler.timesteps)) # timestep_id = torch.randint(min_timestep_boundary, max_timestep_boundary, (1,)) # timestep = pipe.scheduler.timesteps[timestep_id].to(dtype=pipe.torch_dtype, device=pipe.device) # noise = torch.randn_like(inputs["input_latents"]) # inputs["latents"] = pipe.scheduler.add_noise(inputs["input_latents"], noise, timestep)#(1 - sigma) * inputs["input_latents"] + sigma * noise # training_target = pipe.scheduler.training_target(inputs["input_latents"], noise, timestep)#noise-inputs["input_latents"] # models = {name: getattr(pipe, name) for name in pipe.in_iteration_models} # noise_pred = pipe.model_fn(**models, **inputs, timestep=timestep) # # print("loss",noise_pred.shape,training_target.shape)#loss torch.Size([1, 16, 128, 128]) torch.Size([1, 16, 128, 128]) # loss = torch.nn.functional.mse_loss(noise_pred.float(), training_target.float()) # loss = loss * pipe.scheduler.training_weight(timestep) # return loss def FlowMatchSFTLoss(pipe: BasePipeline, **inputs): max_timestep_boundary = int(inputs.get("max_timestep_boundary", 1) * len(pipe.scheduler.timesteps)) min_timestep_boundary = int(inputs.get("min_timestep_boundary", 0) * len(pipe.scheduler.timesteps)) timestep_id = torch.randint(min_timestep_boundary, max_timestep_boundary, (1,)) timestep = pipe.scheduler.timesteps[timestep_id].to(dtype=pipe.torch_dtype, device=pipe.device) noise = torch.randn_like(inputs["input_latents"]) inputs["latents"] = pipe.scheduler.add_noise(inputs["input_latents"], noise, timestep)#(1 - sigma) * inputs["input_latents"] + sigma * noise training_target = pipe.scheduler.training_target(inputs["input_latents"], noise, timestep)#noise-inputs["input_latents"] models = {name: getattr(pipe, name) for name in pipe.in_iteration_models} noise_pred = pipe.model_fn(**models, **inputs, timestep=timestep) # 1. 计算基础 MSE Loss (不归约，保留 B, C, H, W) # loss_elementwise shape: [B, 16, 128, 128] loss_elementwise = torch.nn.functional.mse_loss(noise_pred.float(), training_target.float(), reduction='none') # 2. 获取 Embedder 传来的 Mask loss_weight_mask = inputs.get("loss_weight_mask", None) if loss_weight_mask is not None: # 确保类型匹配 (虽然 mask 通常也是 float16/bfloat16) # loss_weight_mask shape: [B, 1, 128, 128] -> 广播到 [B, 16, 128, 128] # 核心：加权 weighted_loss_sum = (loss_elementwise * loss_weight_mask).sum() # 归一化：分母必须是权重的总和 (考虑 Channel 维度) # 比如一个像素权重是 10，通道数 16，那么这个像素贡献的分母是 10 * 16 num_channels = loss_elementwise.shape[1] # print("num_channels",num_channels) 16 weight_sum = loss_weight_mask.sum() * num_channels + 1e-6 loss = weighted_loss_sum / weight_sum else: loss = loss_elementwise.mean() # Time weighting loss = loss * pipe.scheduler.training_weight(timestep) return loss def DirectDistillLoss(pipe: BasePipeline, **inputs): pipe.scheduler.set_timesteps(inputs["num_inference_steps"]) pipe.scheduler.training = True models = {name: getattr(pipe, name) for name in pipe.in_iteration_models} for progress_id, timestep in enumerate(pipe.scheduler.timesteps): timestep = timestep.unsqueeze(0).to(dtype=pipe.torch_dtype, device=pipe.device) noise_pred = pipe.model_fn(**models, **inputs, timestep=timestep, progress_id=progress_id) inputs["latents"] = pipe.step(pipe.scheduler, progress_id=progress_id, noise_pred=noise_pred, **inputs) loss = torch.nn.functional.mse_loss(inputs["latents"].float(), inputs["input_latents"].float()) return loss class TrajectoryImitationLoss(torch.nn.Module): def __init__(self): super().__init__() self.initialized = False def initialize(self, device): import lpips # TODO: remove it self.loss_fn = lpips.LPIPS(net='alex').to(device) self.initialized = True def fetch_trajectory(self, pipe: BasePipeline, timesteps_student, inputs_shared, inputs_posi, inputs_nega, num_inference_steps, cfg_scale): trajectory = [inputs_shared["latents"].clone()] pipe.scheduler.set_timesteps(num_inference_steps, target_timesteps=timesteps_student) models = {name: getattr(pipe, name) for name in pipe.in_iteration_models} for progress_id, timestep in enumerate(pipe.scheduler.timesteps): timestep = timestep.unsqueeze(0).to(dtype=pipe.torch_dtype, device=pipe.device) noise_pred = pipe.cfg_guided_model_fn( pipe.model_fn, cfg_scale, inputs_shared, inputs_posi, inputs_nega, **models, timestep=timestep, progress_id=progress_id ) inputs_shared["latents"] = pipe.step(pipe.scheduler, progress_id=progress_id, noise_pred=noise_pred.detach(), **inputs_shared) trajectory.append(inputs_shared["latents"].clone()) return pipe.scheduler.timesteps, trajectory def align_trajectory(self, pipe: BasePipeline, timesteps_teacher, trajectory_teacher, inputs_shared, inputs_posi, inputs_nega, num_inference_steps, cfg_scale): loss = 0 pipe.scheduler.set_timesteps(num_inference_steps, training=True) models = {name: getattr(pipe, name) for name in pipe.in_iteration_models} for progress_id, timestep in enumerate(pipe.scheduler.timesteps): timestep = timestep.unsqueeze(0).to(dtype=pipe.torch_dtype, device=pipe.device) progress_id_teacher = torch.argmin((timesteps_teacher - timestep).abs()) inputs_shared["latents"] = trajectory_teacher[progress_id_teacher] noise_pred = pipe.cfg_guided_model_fn( pipe.model_fn, cfg_scale, inputs_shared, inputs_posi, inputs_nega, **models, timestep=timestep, progress_id=progress_id ) sigma = pipe.scheduler.sigmas[progress_id] sigma_ = 0 if progress_id + 1 >= len(pipe.scheduler.timesteps) else pipe.scheduler.sigmas[progress_id + 1] if progress_id + 1 >= len(pipe.scheduler.timesteps): latents_ = trajectory_teacher[-1] else: progress_id_teacher = torch.argmin((timesteps_teacher - pipe.scheduler.timesteps[progress_id + 1]).abs()) latents_ = trajectory_teacher[progress_id_teacher] target = (latents_ - inputs_shared["latents"]) / (sigma_ - sigma) loss = loss + torch.nn.functional.mse_loss(noise_pred.float(), target.float()) * pipe.scheduler.training_weight(timestep) return loss def compute_regularization(self, pipe: BasePipeline, trajectory_teacher, inputs_shared, inputs_posi, inputs_nega, num_inference_steps, cfg_scale): inputs_shared["latents"] = trajectory_teacher[0] pipe.scheduler.set_timesteps(num_inference_steps) models = {name: getattr(pipe, name) for name in pipe.in_iteration_models} for progress_id, timestep in enumerate(pipe.scheduler.timesteps): timestep = timestep.unsqueeze(0).to(dtype=pipe.torch_dtype, device=pipe.device) noise_pred = pipe.cfg_guided_model_fn( pipe.model_fn, cfg_scale, inputs_shared, inputs_posi, inputs_nega, **models, timestep=timestep, progress_id=progress_id ) inputs_shared["latents"] = pipe.step(pipe.scheduler, progress_id=progress_id, noise_pred=noise_pred.detach(), **inputs_shared) image_pred = pipe.vae_decoder(inputs_shared["latents"]) image_real = pipe.vae_decoder(trajectory_teacher[-1]) loss = self.loss_fn(image_pred.float(), image_real.float()) return loss def forward(self, pipe: BasePipeline, inputs_shared, inputs_posi, inputs_nega): if not self.initialized: self.initialize(pipe.device) with torch.no_grad(): pipe.scheduler.set_timesteps(8) timesteps_teacher, trajectory_teacher = self.fetch_trajectory(inputs_shared["teacher"], pipe.scheduler.timesteps, inputs_shared, inputs_posi, inputs_nega, 50, 2) timesteps_teacher = timesteps_teacher.to(dtype=pipe.torch_dtype, device=pipe.device) loss_1 = self.align_trajectory(pipe, timesteps_teacher, trajectory_teacher, inputs_shared, inputs_posi, inputs_nega, 8, 1) loss_2 = self.compute_regularization(pipe, trajectory_teacher, inputs_shared, inputs_posi, inputs_nega, 8, 1) loss = loss_1 + loss_2 return loss