ttv_utils/feature_predictor.py

"""
特征预测器模块

该模块使用钩子机制从模型的中间层特征向量预测分类结果
"""

import torch
import torch.nn as nn
import json
import os
import torch.nn.functional as F
import numpy as np
from typing import Type, Union, Optional

class FeaturePredictor:
    def __init__(self, model_class, model_weights_path, layer_info_path, device='cuda' if torch.cuda.is_available() else 'cpu'):
        """
        初始化特征预测器
        
        Args:
            model_class: 模型类
            model_weights_path: 模型权重文件路径
            layer_info_path: 层信息文件路径
            device: 运行设备
        """
        self.device = device
        self.model = model_class().to(device)
        self.model.load_state_dict(torch.load(model_weights_path, map_location=device, weights_only=True))
        self.model.eval()  
        # 加载层信息
        with open(layer_info_path, 'r') as f:
            layer_info = json.load(f)
        self.target_layer = layer_info['layer_id']
        self.feature_dim = layer_info['dim']
        
        # 初始化变量
        self.output_shape = None
        self.inject_feature = None
        self.handles = []
        self.layer_name_map = {}
        
        # 用于调试的变量
        self.last_normalized_feature = None
        self.last_reshaped_feature = None
        self.last_layer_outputs = {}
        
        # 注册钩子
        self.register_hooks()
        
        # 运行一次前向传播来获取形状
        self._get_output_shape()
        
    def _get_output_shape(self):
        """运行一次前向传播来获取目标层的输出形状"""
        def shape_hook(module, input, output):
            self.output_shape = output.shape[1:]  # 不包括batch维度
            print(f"[Init] 获取到目标层输出形状: {self.output_shape}")
            return output
            
        # 找到目标层并注册临时钩子
        def find_layer(module, name=''):
            for n, child in module.named_children():
                current_name = f"{name}.{n}" if name else n
                if current_name == self.target_layer:
                    handle = child.register_forward_hook(shape_hook)
                    return handle, True
                else:
                    handle, found = find_layer(child, current_name)
                    if found:
                        return handle, True
            return None, False
            
        # 注册临时钩子
        handle, found = find_layer(self.model)
        if not found:
            raise ValueError(f"未找到目标层: {self.target_layer}")
            
        # 运行一次前向传播
        with torch.no_grad():
            dummy_input = torch.zeros(1, 3, 32, 32).to(self.device)
            self.model(dummy_input)
            
        # 移除临时钩子
        handle.remove()
        
        if self.output_shape is None:
            raise RuntimeError("无法获取目标层的输出形状")
    
    def register_hooks(self):
        """注册钩子函数，在目标层注入特征向量和监控每层输出"""
        def print_tensor_info(name, tensor):
            """打印张量的统计信息"""
            print(f"\n[Hook Debug] {name}:")
            print(f"- 形状: {tensor.shape}")
            print(f"- 数值范围: [{tensor.min().item():.4f}, {tensor.max().item():.4f}]")
            print(f"- 均值: {tensor.mean().item():.4f}")
            print(f"- 标准差: {tensor.std().item():.4f}")
        
        def hook_fn(module, input, output):
            """钩子函数：输出层信息并在目标层注入特征"""
            layer_name = self.layer_name_map.get(module, "未知层")
            print(f"\n[Hook Debug] 层: {layer_name}")
            print(f"- 类型: {type(module).__name__}")
            
            # 输出输入信息
            if input and len(input) > 0:
                print_tensor_info("输入张量", input[0])
            
            # 输出原始输出信息
            print_tensor_info("输出张量", output)
            
            # 如果是目标层且有注入特征，则替换输出
            if layer_name == self.target_layer and self.inject_feature is not None:
                print("\n[Hook Debug] 正在注入特征...")
                print_tensor_info("注入特征", self.inject_feature)
                print(f"[Hook Debug] 将层 {layer_name} 的输出从 {output.shape} 替换为注入特征 {self.inject_feature.shape}")     
                # 替换输出
                output = self.inject_feature
                print("[Hook Debug] 特征注入完成，将作为下一层的输入")
                return output
            
            return output
        
        def hook_layer(module, name=''):
            """为每一层注册钩子"""
            for n, child in module.named_children():
                current_name = f"{name}.{n}" if name else n
                # 保存层名到模块的映射
                self.layer_name_map[child] = current_name
                # 注册钩子
                handle = child.register_forward_hook(hook_fn)
                self.handles.append(handle)
                # 递归处理子模块
                hook_layer(child, current_name)
        
        # 注册所有层的钩子
        hook_layer(self.model)
        print(f"[Debug] 钩子注册完成，共注册了 {len(self.handles)} 个钩子")
    
    def reshape_feature(self, feature):
        """调整特征向量的形状"""
        if self.output_shape is None:
            raise RuntimeError("目标层的输出形状未初始化")
        
        batch_size = feature.shape[0]
        expected_dim = np.prod(self.output_shape)
        
        # 检查输入特征维度是否正确
        if feature.shape[1] != expected_dim:
            raise ValueError(f"特征维度不匹配：预期 {expected_dim}，实际 {feature.shape[1]}")
        
        # 使用自动获取的形状重塑特征
        new_shape = (batch_size,) + self.output_shape
        print(f"[Debug] 调整特征形状: {feature.shape} -> {new_shape}")
        return feature.view(new_shape)
    
    def predict(self, feature):
        """使用给定的特征向量进行预测"""
        print(f"\n[Debug] 开始预测，输入特征形状: {feature.shape}")
        
        # 检查输入维度
        if feature.shape[1] != self.feature_dim:
            raise ValueError(f"特征维度不匹配：预期 {self.feature_dim}，实际 {feature.shape[1]}")
        
        # 将特征转移到正确的设备并重塑
        feature = feature.to(self.device)
        self.inject_feature = self.reshape_feature(feature)
        
        # 使用虚拟输入进行预测
        dummy_input = torch.zeros(feature.shape[0], 3, 32, 32).to(self.device)
        
        # 进行前向传播（钩子会自动在目标层注入特征）
        with torch.no_grad():
            output = self.model(dummy_input)
        
        # 清除注入的特征
        self.inject_feature = None
        
        return output

def predict_feature(
    model: Type[nn.Module],
    weight_path: str,
    layer_info_path: str,
    feature: Union[torch.Tensor, np.ndarray],
    device: Optional[str] = None
) -> torch.Tensor:
    """
    使用预训练模型预测特征向量的类别。

    Args:
        model: PyTorch模型类（不是实例）
        weight_path: 模型权重文件路径
        layer_info_path: 层信息配置文件路径
        feature: 输入特征向量，可以是torch.Tensor或numpy.ndarray
        device: 运行设备，可选 'cuda' 或 'cpu'。如果为None，将自动选择。

    Returns:
        torch.Tensor: 模型输出的预测结果

    Raises:
        ValueError: 如果输入特征维度不正确
        FileNotFoundError: 如果权重文件或层信息文件不存在
        RuntimeError: 如果模型加载或预测过程出错
    """
    try:
        # 检查文件是否存在
        if not os.path.exists(weight_path):
            raise FileNotFoundError(f"权重文件不存在: {weight_path}")
        if not os.path.exists(layer_info_path):
            raise FileNotFoundError(f"层信息文件不存在: {layer_info_path}")

        # 确定设备
        if device is None:
            device = 'cuda' if torch.cuda.is_available() else 'cpu'

        # 转换输入特征为torch.Tensor
        if isinstance(feature, np.ndarray):
            feature = torch.from_numpy(feature).float()
        elif not isinstance(feature, torch.Tensor):
            raise ValueError("输入特征必须是numpy数组或torch张量")

        # 创建预测器实例
        predictor = FeaturePredictor(
            model_class=model,
            model_weights_path=weight_path,
            layer_info_path=layer_info_path,
            device=device
        )

        # 进行预测
        with torch.no_grad():
            output = predictor.predict(feature)

        return output

    except Exception as e:
        raise RuntimeError(f"预测过程出错: {str(e)}")


def test_predictor():
    """测试特征预测器的功能"""
    from AlexNet.code.model import AlexNet
    import os
    import numpy as np
    
    # 创建预测器实例
    predictor = FeaturePredictor(
            model_class=AlexNet,
            model_weights_path='AlexNet/model/0/epoch_195/subject_model.pth',
            layer_info_path='AlexNet/code/layer_info.json'
    )
    
    print("\n开始单点测试...")
    
    # 生成一个测试点，使用较大的尺度以增加特征的差异性
    feature = torch.randn(1, predictor.feature_dim) * 10.0
    output = predictor.predict(feature)
    probs = output.softmax(dim=1)
    print("\n结果:",output)
    # 显示最终预测结果
    print("\n最终预测结果:")
    top_k = torch.topk(probs[0], k=3)
    for idx, (class_idx, prob) in enumerate(zip(top_k.indices.tolist(), top_k.values.tolist())):
        print(f"Top-{idx+1}: 类别 {class_idx}, 概率 {prob:.4f}")

def test_predictor_from_train_data():
    """测试特征预测器的批量预测功能"""
    from AlexNet.code.model import AlexNet
    import numpy as np
    import torch
    
    print("\n开始处理训练数据集...")
    # 创建预测器实例
    predictor = FeaturePredictor(
        model_class=AlexNet,
        model_weights_path='AlexNet/model/0/epoch_195/subject_model.pth',
        layer_info_path='AlexNet/code/layer_info.json'
    )
    
    # 加载训练数据
    print("\n加载训练数据...")
    features = np.load('AlexNet/model/0/epoch_195/train_data.npy')
    print(f"数据形状: {features.shape}")
    
    # 转换为tensor
    features = torch.from_numpy(features).float()
    
    # 批量处理
    batch_size = 100
    num_samples = len(features)
    num_batches = (num_samples + batch_size - 1) // batch_size
    
    # 用于统计结果
    all_predictions = []
    class_counts = {}
    
    print("\n开始批量预测...")
    with torch.no_grad():
        for i in range(num_batches):
            start_idx = i * batch_size
            end_idx = min((i + 1) * batch_size, num_samples)
            batch_features = features[start_idx:end_idx]
            
            # 使用预测器进行预测
            outputs = predictor.predict(batch_features)
            predictions = outputs.argmax(dim=1).cpu().numpy()
            
            # 更新统计信息
            for pred in predictions:
                class_counts[int(pred)] = class_counts.get(int(pred), 0) + 1
            
            all_predictions.extend(predictions)
            
            # 打印进度和当前批次的预测分布
            if (i + 1) % 10 == 0:
                print(f"\n已处理: {end_idx}/{num_samples} 个样本")
                batch_unique, batch_counts = np.unique(predictions, return_counts=True)
                print("当前批次预测分布:")
                for class_idx, count in zip(batch_unique, batch_counts):
                    print(f"类别 {class_idx}: {count} 个样本 ({count/len(predictions)*100:.2f}%)")
    
    # 打印总体统计结果
    print("\n最终预测结果统计:")
    total_samples = len(all_predictions)
    for class_idx in sorted(class_counts.keys()):
        count = class_counts[class_idx]
        percentage = (count / total_samples) * 100
        print(f"类别 {class_idx}: {count} 个样本 ({percentage:.2f}%)")

def test_train_data():
    """测试训练数据集的预测结果分布"""
    from AlexNet.code.model import AlexNet
    import numpy as np
    import torch
    import torch.nn.functional as F
    
    print("\n开始处理训练数据集...")
    
    # 初始化模型
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    model = AlexNet().to(device)
    model.load_state_dict(torch.load('AlexNet/model/0/epoch_195/subject_model.pth', 
                                   map_location=device, weights_only=True))
    model.eval()
    
    # 加载训练数据
    print("加载训练数据...")
    features = np.load('AlexNet/model/0/epoch_195/train_data.npy')
    print(f"数据形状: {features.shape}")
    
    # 转换为tensor
    features = torch.from_numpy(features).float().to(device)
    
    # 批量处理
    batch_size = 100
    num_samples = len(features)
    num_batches = (num_samples + batch_size - 1) // batch_size
    
    # 用于统计结果
    all_predictions = []
    class_counts = {}
    
    print("\n开始批量预测...")
    with torch.no_grad():
        for i in range(num_batches):
            start_idx = i * batch_size
            end_idx = min((i + 1) * batch_size, num_samples)
            batch_features = features[start_idx:end_idx]
            
            # 将特征重塑为[batch_size, 16, 8, 8]
            reshaped_features = batch_features.view(-1, 16, 8, 8)
            
            # 使用模型的predict函数
            outputs = model.predict(reshaped_features)
            predictions = outputs.argmax(dim=1).cpu().numpy()
            
            # 更新统计信息
            for pred in predictions:
                class_counts[int(pred)] = class_counts.get(int(pred), 0) + 1
            
            all_predictions.extend(predictions)
            
            # 打印进度
            if (i + 1) % 10 == 0:
                print(f"已处理: {end_idx}/{num_samples} 个样本")
    
    # 打印统计结果
    print("\n预测结果统计:")
    total_samples = len(all_predictions)
    for class_idx in sorted(class_counts.keys()):
        count = class_counts[class_idx]
        percentage = (count / total_samples) * 100
        print(f"类别 {class_idx}: {count} 个样本 ({percentage:.2f}%)")
    
    # 保存详细结果
    print("\n保存详细结果...")
    results = {
        'predictions': all_predictions,
        'class_counts': class_counts
    }
    # np.save('prediction_results.npy', results)
    # print("结果已保存到 prediction_results.npy")



if __name__ == "__main__":
    test_predictor()
    # test_predictor_from_train_data()
    # test_train_data()