analysis/decoupling_analysis/3loss/gradient_analysis/gradient_analysis.py

"""
梯度冲突分析 - 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()")