File size: 9,895 Bytes
c9aee57 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 | """
梯度冲突分析 - 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()")
|