""" 梯度冲突分析 - Gradient Conflict Analysis 基于 PCGrad 论文的分析方法（不用来解决冲突，只用来证明冲突存在） 使用方法： 1. 在 Integrated Distillation 训练过程中，分别计算 L_content 和 L_context 的梯度 2. 计算梯度余弦相似度 3. 逐层分析 参考: https://arxiv.org/pdf/2001.06782 (PCGrad: Gradient Surgery for Multi-Task Learning) """ import torch import torch.nn.functional as F from typing import Dict, List, Tuple, Optional import numpy as np import json import os from collections import defaultdict class GradientConflictAnalyzer: """ 梯度冲突分析器 用于分析 Content Loss 和 Context Loss 的梯度是否冲突 """ def __init__(self, save_dir: str = "gradient_analysis_results"): self.save_dir = save_dir os.makedirs(save_dir, exist_ok=True) # 存储分析结果 self.layer_cosine_similarities = defaultdict(list) # {layer_name: [cos_sim_iter1, cos_sim_iter2, ...]} self.global_cosine_similarities = [] self.iteration_count = 0 def analyze_gradient_conflict( self, model: torch.nn.Module, loss_content: torch.Tensor, loss_context: torch.Tensor, analysis_layers: Optional[List[str]] = None ) -> Dict[str, float]: """ 分析 Content 和 Context Loss 的梯度冲突 Args: model: 模型 loss_content: Content Loss loss_context: Context Loss analysis_layers: 需要分析的层名称列表，如果为 None 则分析所有层 Returns: Dict[str, float]: 每层的梯度余弦相似度 """ self.iteration_count += 1 layer_cos_sims = {} # 获取需要分析的参数 params_dict = {} for name, param in model.named_parameters(): if param.requires_grad: if analysis_layers is None or any(layer in name for layer in analysis_layers): params_dict[name] = param if not params_dict: return {} params_list = list(params_dict.values()) param_names = list(params_dict.keys()) try: # 计算 content loss 的梯度 grad_content = torch.autograd.grad( loss_content, params_list, retain_graph=True, allow_unused=True, create_graph=False ) # 计算 context loss 的梯度 grad_context = torch.autograd.grad( loss_context, params_list, retain_graph=True, allow_unused=True, create_graph=False ) # 逐层计算余弦相似度 for name, g_content, g_context in zip(param_names, grad_content, grad_context): if g_content is None or g_context is None: continue g_content_flat = g_content.flatten() g_context_flat = g_context.flatten() if g_content_flat.numel() == 0 or g_context_flat.numel() == 0: continue # 计算余弦相似度 cos_sim = F.cosine_similarity( g_content_flat.unsqueeze(0), g_context_flat.unsqueeze(0) ).item() # 提取层名（简化） layer_name = self._simplify_layer_name(name) layer_cos_sims[layer_name] = cos_sim self.layer_cosine_similarities[layer_name].append(cos_sim) # 计算全局余弦相似度 all_grad_content = torch.cat([g.flatten() for g in grad_content if g is not None]) all_grad_context = torch.cat([g.flatten() for g in grad_context if g is not None]) if all_grad_content.numel() > 0 and all_grad_context.numel() > 0: global_cos_sim = F.cosine_similarity( all_grad_content.unsqueeze(0), all_grad_context.unsqueeze(0) ).item() self.global_cosine_similarities.append(global_cos_sim) layer_cos_sims["global"] = global_cos_sim except Exception as e: print(f"Gradient analysis error at iteration {self.iteration_count}: {e}") return layer_cos_sims def _simplify_layer_name(self, name: str) -> str: """简化层名称""" # 例如: visual.blocks.11.attn.q_proj.weight -> blocks.11.attn parts = name.split(".") if "blocks" in name: idx = parts.index("blocks") if idx + 1 < len(parts): block_num = parts[idx + 1] if idx + 2 < len(parts): sub_module = parts[idx + 2] return f"blocks.{block_num}.{sub_module}" return f"blocks.{block_num}" return name def get_statistics(self) -> Dict: """获取统计信息""" stats = { "total_iterations": self.iteration_count, "layer_statistics": {}, "global_statistics": {} } # 逐层统计 for layer_name, cos_sims in self.layer_cosine_similarities.items(): if cos_sims: cos_array = np.array(cos_sims) stats["layer_statistics"][layer_name] = { "mean": float(np.mean(cos_array)), "std": float(np.std(cos_array)), "min": float(np.min(cos_array)), "max": float(np.max(cos_array)), "conflict_ratio": float(np.mean(cos_array < 0)), # 冲突比例（余弦相似度<0） "orthogonal_ratio": float(np.mean(np.abs(cos_array) < 0.1)), # 正交比例 } # 全局统计 if self.global_cosine_similarities: global_array = np.array(self.global_cosine_similarities) stats["global_statistics"] = { "mean": float(np.mean(global_array)), "std": float(np.std(global_array)), "min": float(np.min(global_array)), "max": float(np.max(global_array)), "conflict_ratio": float(np.mean(global_array < 0)), "orthogonal_ratio": float(np.mean(np.abs(global_array) < 0.1)), } return stats def save_results(self, filename: str = "gradient_analysis.json"): """保存分析结果""" results = { "statistics": self.get_statistics(), "raw_data": { "layer_cosine_similarities": {k: v for k, v in self.layer_cosine_similarities.items()}, "global_cosine_similarities": self.global_cosine_similarities } } filepath = os.path.join(self.save_dir, filename) with open(filepath, "w") as f: json.dump(results, f, indent=2) print(f"Gradient analysis results saved to {filepath}") return filepath def print_summary(self): """打印分析摘要""" stats = self.get_statistics() print("\n" + "="*60) print("Gradient Conflict Analysis Summary") print("="*60) print(f"Total iterations analyzed: {stats['total_iterations']}") if stats["global_statistics"]: g = stats["global_statistics"] print(f"\nGlobal Statistics:") print(f" Mean cos similarity: {g['mean']:.4f}") print(f" Std: {g['std']:.4f}") print(f" Range: [{g['min']:.4f}, {g['max']:.4f}]") print(f" Conflict ratio (cos < 0): {g['conflict_ratio']*100:.1f}%") print(f" Orthogonal ratio (|cos| < 0.1): {g['orthogonal_ratio']*100:.1f}%") print(f"\nPer-Layer Statistics (sorted by conflict ratio):") layer_stats = stats["layer_statistics"] sorted_layers = sorted(layer_stats.items(), key=lambda x: x[1]["conflict_ratio"], reverse=True) for layer_name, s in sorted_layers[:10]: # 只显示前10层 print(f" {layer_name}:") print(f" mean={s['mean']:.4f}, conflict_ratio={s['conflict_ratio']*100:.1f}%") print("="*60 + "\n") def analyze_gradient_conflict_in_training( model: torch.nn.Module, loss_content: torch.Tensor, loss_context: torch.Tensor, iteration: int, analyzer: GradientConflictAnalyzer, analysis_frequency: int = 100 ) -> Optional[Dict[str, float]]: """ 在训练过程中分析梯度冲突的便捷函数 Args: model: 模型 loss_content: Content Loss loss_context: Context Loss iteration: 当前迭代 analyzer: GradientConflictAnalyzer 实例 analysis_frequency: 分析频率（每隔多少个 iteration 分析一次） Returns: 如果进行了分析，返回余弦相似度字典；否则返回 None """ if iteration % analysis_frequency != 0: return None return analyzer.analyze_gradient_conflict( model, loss_content, loss_context, analysis_layers=["blocks", "attn", "mlp"] # 分析 attention 和 MLP 层 ) if __name__ == "__main__": # 示例用法 print("Gradient Conflict Analyzer") print("Usage:") print(" 1. Create analyzer: analyzer = GradientConflictAnalyzer('save_dir')") print(" 2. In training loop: analyzer.analyze_gradient_conflict(model, loss_content, loss_context)") print(" 3. After training: analyzer.print_summary() and analyzer.save_results()")